SpringBoot【SpringBoot指标监控、SpringBoot日志管理、SpringBoot项目部署、 SpringBoot容器化部署】(五)

 

目录

SpringBoot指标监控_添加Actuator功能

 SpringBoot指标监控_Spring Boot Admin

 SpringBoot日志管理

SpringBoot项目部署_项目打包

 SpringBoot项目部署_多环境配置

 SpringBoot容器化部署_安装Docker环境

SpringBoot容器化部署_Dockerfile制作镜像

SpringBoot容器化部署_Maven插件制作镜像 

Spring Task_定时任务

Spring Task_入门案例 

Spring Task_Cron表达式

 Spring Task_Cron实战案例

Spring Task_@Scheduled

Spring Task_多线程任务

---

 

SpringBoot指标监控_添加Actuator功能

 Spring Boot Actuator可以帮助程序员监控和管理SpringBoot应 用，比如健康检查、内存使用情况统计、线程使用情况统计等。我 们在SpringBoot项目中添加Actuator功能，即可使用Actuator监控 项目，用法如下：

 1.在被监控的项目中添加Actuator起步依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2.编写配置文件

#开启所有监控端点
management.endpoints.web.exposure.include= *

 3.访问项目：http://localhost:8080/actuator

 通过URL可以调用actuator的功能：

 SpringBoot指标监控_Spring Boot Admin

 Actuator使用JSON格式展示了大量指标数据，不利于我们查看，我 们可以使用可视化工具Spring Boot Admin查看actuator生成指标 数据。Spring Boot Admin是一个独立的项目，我们需要创建并运 行该项目。

 创建Spring Boot Admin服务端项目

1.创建SpringBoot项目，添加SpringMVC和Spring Boot Admin服 务端起步依赖

<dependency>  
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
</dependency>

2.修改配置文件

# 端口号
server.port=9090
#日志格式
logging.pattern.console=%d{HH:mm:ss.SSS} %clr(%-5level) --- [%-15thread] %cyan(%-50logger{50}):%msg%n

3.修改启动类

@SpringBootApplication
@EnableAdminServer //开启Spring Boot Admin
服务端
public class MyadminApplication {
    public static void main(String[] args)
     {
      
      SpringApplication.run(MyadminApplication.class, args);
     }
}

连接Spring Boot Admin项目 在被监控的项目中连接Spring Boot Admin项目，才能使用Spring Boot Admin查看指标数据。

 1.被监控项目添加Spring Boot Admin客户端起步依赖

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>2.6.0</version>
</dependency>

2.修改配置文件

#Spring boot admin访问地址
spring.boot.admin.client.url=http://localhost:9090

3.此时Spring Boot Admin即可连接被监控的项目

 SpringBoot日志管理

SpringBoot默认使用Logback组件作为日志管理。Logback是log4j 创始人设计的一个开源日志组件。在SpringBoot项目中我们不需要 额外的添加Logback的依赖，因为在 spring-boot-parent 中已经包含了 Logback的依赖。 

 1.在 /resources 下添加Logback配置文件logback.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <!--定义日志文件的存储地址-->
    <property name="LOG_HOME" value="${catalina.base}/logs/"/>
    
    <!-- 控制台输出 -->
    <appender name="Stdout"  class="ch.qos.logback.core.ConsoleAppender">
        <!-- 日志输出编码 -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{MM-dd HH:mm:ss.SSS} [%thread] %-5level%logger{50} - %msg%n
            </pattern>
        </layout>
    </appender>
    
    <!-- 按照每天生成日志文件 -->
    <appender name="RollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBas edRollingPolicy">
            <!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/server.%d{yy 99-MM-dd}.log</FileNamePattern>
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <layout class="ch.qos.logback.classic.PatternLayout">
            <!--格式化输出：%d表示时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
            </pattern>
        </layout>
        <!--日志文件最大的大小-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
          
<MaxFileSize>10MB</MaxFileSize>
        </triggeringPolicy>
    </appender>
    <!-- 日志输出级别 -->
    <root level="info">
        <appender-ref ref="Stdout"/>
        <appender-ref ref="RollingFile"/>
    </root>
</configuration>

 注：Logback配置文件名为logback-test.xml或 logback.xml，如果classpath下没有这两个文件，LogBack 会自动进行最小化配置。

 2.在代码中打印日志

@Controller
public class LogbackController {
    private final static Logger logger = LoggerFactory.getLogger(LogbackController.class);
    @RequestMapping("/printLog")
    @ResponseBody
    public String showInfo(){
        logger.info("记录日志");
        return "Hello Logback";
   }
}

3.如果日志过多，可以屏蔽一些包的日志，在配置文件中配置

#屏蔽org包中的日志输出
logging.level.org=off

补充：Log4j2安全漏洞 在2021年12月，Log4j2爆出了极其严重的安全漏洞，攻击者可 以让记录的日志包含指定字符串，从而执行任意程序。很多大 型网站，如百度等都是此次Log4j漏洞的受害者，很多互联网企 业连夜做了应急措施。 Log4j2.0到2.14.1全部存在此漏洞，危害范围极其广泛， Log4j2.15.0-rc1中修复了这个 bug。

因Log4j2漏洞的反复无常，导致某些公司已经切换到Logback 来记录日志，但在Log4j2漏洞爆出后，Logback也爆出漏洞： 在Logback1.2.7及之前的版本中，具有编辑配置文件权限的攻 击者可以制作恶意配置，允许从LDAP服务器加载、执行任意代 码。 解决方案为将Logback升级到安全版本： Logback1.2.9+ SpringBoot2.6.2以上的Logback版本已经升到了1.2.9，Log4j2 的版本也升到了2.17.0，所以我们使用SpringBoot2.6.2以上版 本无需担心Log4j2和Logback安全漏洞。

SpringBoot项目部署_项目打包

SpringBoot项目是依赖于Maven构建的，但打包时如果只依赖 Maven打包工具则会打包不完整，我们还需要在SpringBoot项目中 引入SpringBoot打包插件 ： 

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-mavenplugin</artifactId>
        </plugin>
    </plugins>
</build>

此时再使用Maven插件打包：

 

打包后jar包解压目录如下： 

 

 可以看到该目录少了BOOT-INF，打包是不完整的，也无法运行jar 包

运行jar包：

1 进入jar包所在目录，使用cmd打开命令行窗口

2 输入命令：

java -jar jar包名

 SpringBoot项目部署_多环境配置

 

 在真实开发中，在不同环境下运行项目往往会进行不同的配置，比 如开发环境使用的是开发数据库，测试环境使用的是测试数据库， 生产环境使用的是生产数据库。SpringBoot支持不同环境下使用不 同的配置文件，用法如下：

 配置文件名：

    application-环境名.properties/yml   

如：

  1 application-dev.properties/yml 开发环境配置文件

    

# 开发环境端口号为8080server: port: 8080

  2 application-test.properties/yml 测试环境配置文件

  

# 测试环境端口号为8081server: port: 8081

3 application-prod.properties/yml 生产环境配置文件

# 生产环境端口号为80server: port: 80

 运行jar包时选择环境：

 java -jar jar包名 --spring.profiles.active=环 境名

 SpringBoot容器化部署_安装Docker环境

 为了节约资源，在生产环境中我们更多的是使用Docker容器部署 SpringBoot应用，首先我们准备Docker环境：

1 准备一台centos7系统的虚拟机，连接虚拟机。

2 关闭虚拟机防火墙

# 关闭运行的防火墙systemctl stop firewalld.service # 禁止防火墙自启动 systemctl disable firewalld.service

3. 安装Docker

# 安装Dockeryum -y install docker # 启动docker systemctl start docker

SpringBoot容器化部署_Dockerfile制作镜像

由于在SpringBoot中嵌入了Web容器，所以在制作SpringBoot项目 的镜像时无需依赖Web容器，基于JDK制作镜像即可，接下来我们 使用Dockerfile制作镜像：

1.进入opt目录

cd /opt

2 使用rz命令将项目Jar包上传至虚拟机

3 编写DockerFile

cat <<EOF > Dockerfile# 基于JDK11 FROM openjdk:11 # 作者 MAINTAINER itbaizhan # 拷贝到容器opt目录 ADD springbootdemo7-0.0.1-SNAPSHOT.jar /opt #保留端口 EXPOSE 8080 # 启动容器后执行的命令 CMD java -jar /opt/springbootdemo7-0.0.1- SNAPSHOT.jar --spring.profiles.active=dev EOF

4.构建镜像

docker build -t springbootdocker .

5.查看所有的镜像，出现springbootdocker代表镜像构建成功

docker images

6.使用镜像启动容器

docker run -d -p 8080:8080springbootdocker

7.访问ip地址:8080/printLog查看是否启动成功

SpringBoot容器化部署_Maven插件制作镜像 

除了DockerFile，我们还可以使用Maven插件制作镜像。使用方法 如下：
1.开启远程docker服务
# 修改docker配置文件vim /lib/systemd/system/docker.service
# 在ExecStart=后添加配置，远程访问docker的端口
为2375
ExecStart=/usr/bin/dockerd-current -H
tcp://0.0.0.0:2375 -H
unix://var/run/docker.sock           --add-runtime dockerrunc=/usr/libexec/docker/docker-runccurrent           --default-runtime=docker-runc           --exec-opt
          native.cgroupdriver=systemd           --userland-proxypath=/usr/libexec/docker/docker-proxycurrent           --initpath=/usr/libexec/docker/docker-initcurrent           --seccompprofile=/etc/docker/seccomp.json           $OPTIONS           $DOCKER_STORAGE_OPTIONS           $DOCKER_NETWORK_OPTIONS           $ADD_REGISTRY           $BLOCK_REGISTRY           $INSECURE_REGISTRY           $REGISTRIES
# 重启docker
systemctl daemon-reload
systemctl restart docker
2.在项目的pom文件中添加 docker-maven-plugin 插件
<!-- docker-maven-plugin--><plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-mavenplugin</artifactId>
    <version>1.2.2</version>
    <configuration>
        <!-- Docker路径 -->
    <dockerHost>http://192.168.25.101:2375</dockerHost>
        <!-- Dockerfile定义 -->
        <baseImage>openjdk:11</baseImage>
        <!-- 作者 -->
        <maintainer>xiaotong</maintainer>
        <resources>
            <resource>
                <!-- 复制jar包到docker容器指定目录 -->
                <targetPath>/</targetPath>
                <!-- 从哪个包拷贝文件，target包 -->
              
                <directory>${project.build.directory}
                </directory>
                <!-- 拷贝哪个文件 -->
              
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
        <workdir>/</workdir>
        <entryPoint>["java", "-jar","${project.build.finalName}.jar","--spring.profiles.active=dev"]</entryPoint>
        <forceTags>true</forceTags>
        <!-- 镜像名 -->
        <imageName>${project.artifactId}
        </imageName>
        <!-- 镜像版本 -->
        <imageTags>
            <imageTag>${project.version}
        </imageTag>
        </imageTags>
    </configuration>
</plugin>
3.使用maven的package命令给项目打包

4.使用maven的docker插件制作镜像

 5.查看所有的镜像，出现springbootdemo7代表镜像构建成功

docker images

6.使用镜像启动容器

docker run -d -p 8081:8080springbootdemo7:0.0.1-SNAPSHOT

Spring Task_定时任务

 定时任务即系统在特定时间执行一段代码，它的场景应用非常广 泛：

1 购买游戏的月卡会员后，系统每天给会员发放游戏资源。

2 管理系统定时生成报表。

3 定时清理系统垃圾。

4 ......

定时任务的实现主要有以下几种方式：

1. Java自带的java.util.Timer类，这个类允许调度一个java.util.TimerTask任务。使用这种方式可以让 程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。

2 Quartz。这是一个功能比较强大的的调度器，可以让程序在指定时间执行，也可以按照某一个频度 执行，配置起来稍显复杂。

3  Spring3.0以后自带Spring Task，可以将它看成一个轻量级的Quartz，使用起来比 Quartz简单许 多，在课程中我们使用Spring Task实现定时任务

Spring Task_入门案例 

1.创建SpringBoot项目，在启动类开启定时任务。

@SpringBootApplication
@EnableScheduling
public class Springbootdemo8Application {
    public static void main(String[] args)
   {
      
       SpringApplication.run(Springbootdemo8Application.class, args);
   }
}

2.编写定时任务类

@Component
public class MyTask {
    // 定时任务方法，每秒执行一次
    @Scheduled(cron="* * * * * *")
    public void task1() {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        System.out.println(sdf.format(new Date()));
   }
}

3.启动项目，定时任务方法按照配置定时执行。

Spring Task_Cron表达式

Spring Task依靠Cron表达式配置定时规则。Cron表达式是一个字 符串，分为6或7个域，每一个域代表一个含义，以空格隔开。有如 下两种语法格式： 

1.Seconds Minutes Hours DayofMonth Month DayofWeek Year

2 Seconds Minutes Hours DayofMonth Month DayofWeek

 

 Spring Task_Cron实战案例

 

Spring Task_@Scheduled

 @Scheduled写在方法上方，指定该方法定时执行。常用参数如 下：

      cron：cron表达式，定义方法执行的时间规则。

      fixedDelay：任务立即执行，之后每隔多久执行一次，单位是毫 秒，上一次任务结束后计算下次执行的时间。

// 立即执行，任务结束后每5秒执行一次
@Scheduled(fixedDelay=5000)
public void task1() throws
InterruptedException {
    SimpleDateFormat sdf = new  SimpleDateFormat("HH:mm:ss");
    Thread.sleep(1000);
    System.out.println(sdf.format(new Date()));
}

 fixedRate：任务立即执行，之后每隔多久执行一次，单位是毫 秒，上一次任务开始后计算下次执行的时间。

// 立即执行，之后每5秒执行一次
@Scheduled(fixedRate=5000)
public void task2() throws
InterruptedException {
    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    Thread.sleep(1000);
    System.out.println(sdf.format(new Date()));
}

initialDelay：项目启动后不马上执行定时器，根据initialDelay 的值延时执行。

// 项目启动3秒后执行，之后每5秒执行一次。
@Scheduled(fixedRate=5000,initialDelay =
3000)
public void task3() throws
InterruptedException {
    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    Thread.sleep(1000);
    System.out.println(sdf.format(new Date()));
}

Spring Task_多线程任务

Spring Task定时器默认是单线程的，如果项目中使用多个定时器， 使用一个线程会造成效率低下。代码如下： 

@Scheduled(cron="* * * * * *")
private void task1() throws
InterruptedException {
  
System.out.println(Thread.currentThread().getId()+"线程执行任务1");
    Thread.sleep(5000);
}
@Scheduled(cron="* * * * * *")
private void task2() {
  
System.out.println(Thread.currentThread().getId()+"线程执行任务2");
}

任务1较浪费时间，会阻塞任务2的运行。此时我们可以给Spring Task配置线程池。