SpringBoot高级

搁浅 L2024-03-16 17:29

1.自动配置-Condition

Condition是Spring4.0后引入的条件化配置接口，通过实现Condition接口可以完成有条件的加载相应的Bean

进入 SpringBoot 启动类，点击进入 run()

可以看到这个方法是有返回值的，返回值为 ConfigurableApplicationContext

这个返回值就是 IOC 容器

通过获取 run() 的返回值再获取容器中的bean

导入redis起步依赖

XML 复制代码 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
java 复制代码 
@SpringBootApplication
public class SpringbootConditionApplication {
    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);

        //获取Bean，RedisTemplate
        Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);
    }

案例

在Spring的IOC容器中有一个User的Bean，现要求：

1.导入Jedis坐标后，加载该Bean，没导入，则不加载

XML 复制代码 
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
java 复制代码 
package com.domain;

public class User {
}
java 复制代码 
package com.config;

import com.condition.ClassCondition;
import com.domain.User;
import org.springframework.boot.autoconfigure.security.SecurityProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    @Conditional(ClassCondition.class)
    public User user(){
        return new User();
    }
}
java 复制代码 
package com.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class ClassCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //需求：导入Jedis坐标后创建Bean
        //思路：判断redis.clients.jedis.Jedis.class文件是否存在
        boolean flag = true;
        try {
            Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}
java 复制代码 
package com.springbootcondition;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SpringbootConditionApplication {
    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);

        //获取Bean，RedisTemplate
        /*Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);*/

        Object user = context.getBean("user");
        System.out.println(user);
    }

}

如果把 pom.xml 文件中的 Jedis 坐标注释掉

那么Spring 容器则不会创建 User 对应的 Bean，运行启动类就获取不到 user 对象

2.将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定

java 复制代码 
package com.condition;

import org.springframework.context.annotation.Conditional;

import java.lang.annotation.*;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {
    String[] value();
}
java 复制代码 
package com.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Map;
import java.util.Objects;

public class ClassCondition implements Condition {
    //context  上下文对象。用于获取环境，IOC容器，ClassLoader对象
    //metadata  注解元对象。可以用于获取注解定义的属性值
    /*@Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //需求1：导入Jedis坐标后创建Bean
        //思路：判断redis.clients.jedis.Jedis.class文件是否存在
        boolean flag = true;
        try {
            Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }*/
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //需求2：导入注解属性值value指定坐标后创建Bean
        //获取注解属性值  value
        Map<String, Object> map = metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
        //System.out.println(map);
        String[] value = (String[]) map.get("value");
        boolean flag = true;
        try {
            for (String className : value) {
                Class<?> cls = Class.forName("className");
            }

        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}
java 复制代码 
package com.config;

import com.condition.ConditionOnClass;
import com.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    //@Conditional(ClassCondition.class)
    @ConditionOnClass("redis.clients.jedis.Jedis")
    public User user(){
        return new User();
    }
}
java 复制代码 
package com.springbootcondition;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SpringbootConditionApplication {
    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);

        //获取Bean，RedisTemplate
        /*Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);*/

        Object user = context.getBean("user");
        System.out.println(user);
    }

}

Condition-小结

自定义条件

1.定义条件类：自定义类实现 Condition 接口，重写 matches 方法，在 matches 方法中进行逻辑判断，返回 boolean 值。matches 方法两个参数：

context：上下文对象，可以获取属性值、类加载器、BeanFactory 等

metadata：元数据对象，用于获取注解属性

2.判断条件：在初始化 Bean 时，使用 @Conditional(条件类.class) 注解

SpringBoot 提供的常用条件注解：

ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化Bean

ConditionalOnClass：判断内存在中是否有对应字节码文件才初始化Bean (jar 包有没有导入)

ConditionalOnMissingBean：判断容器中没有对应Bean才初始化Bean(执行这个方法时要求所依赖的bean 已经被初始化了)

2.切换内置web服务器

SpringBoot的web环境中默认使用tomcat作为内置服务器，其实SpringBoot提供了4种内置服务器供我们选择，我们可以很方便的进行切换

XML 复制代码 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!--排除tomcat依赖-->
    <exclusions>
        <exclusion>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>

<!--引入jetty的依赖-->
<dependency>
    <artifactId>spring-boot-starter-jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

3.Enable注解原理

pringBoot中提供了很多Enable开头的注解，这些注解都是用于动态启用某些功能的。而其底层原理是使用@Import注解导入一些配置类，实现Bean的动态加载

java 复制代码 
package com.springbootenable;

import com.config.EnableUser;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * @ComponentScan 扫描范围：当前引导类所在包及其子包
 *
 * com.springbootenable
 * com.config
 * //1.使用@ComponentScan扫描com.config包
 * //2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器
 * //3.可以对Import注解进行封装。
 */

//@ComponentScan("com.config")
//@Import(UserConfig.class)
@EnableUser
@SpringBootApplication
public class SpringbootEnableApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
        //获取Bean
        Object user = context.getBean("user");
        System.out.println(user);
    }
}

pom中引入springboot-enable-other

记得在enable-other中打包（install）

XML 复制代码 
        <pendency>
            <groupId>com</groupId>
            <artifactId>springboot-enable-other</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
java 复制代码 
package com.domain;

public class User {
}
java 复制代码 
package com.config;

import com.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    public User user(){
        return new User();
    }
}
java 复制代码 
package com.config;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}

SpringBoot不能直接获取在其他工程中定义的Bean

原因：@ComponentScan 扫描范围：当前引导类所在包及其子包

三种解决方案：

1.使用@ComponentScan扫描com.lichee.config包

2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器

3.可以对Import注解进行封装

注：Enable注解底层原理是使用@Import注解实现Bean的动态加载

4.@Import详解

@Enable*底层依赖于@Import注解导入一些类，使用@Import导入的类会被Spring加载到IOC容器中。而@Import提供4中用法：

1.导入Bean

2.导入配置类

3.导入 ImportSelector 实现类。一般用于加载配置文件中的类

4.导入 ImportBeanDefinitionRegistrar 实现类。

java 复制代码 
package com.domain;

public class Role {
}
java 复制代码 
package com.config;

import com.domain.Role;
import com.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    public User user(){
        return new User();
    }
    @Bean
    public Role role(){
        return new Role();
    }
}

导入Bean @Import(User.class)

导入配置类 @Import(UserConfig.class)

导入 ImportSelector 实现类 @Import(MyImportSelector.class)

java 复制代码 
package com.springbootenable;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.domain.User", "com.domain.Role"};
    }
}

导入 ImportBeanDefinitionRegistrar 实现类。@Import({MyImportBeanDefinitionRegistrar.class})

java 复制代码 
package com.springbootenable;

import com.domain.User;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        registry.registerBeanDefinition("user", beanDefinition);
    }
}

SpringbootEnableApplication测试代码

java 复制代码 
package com.springbootenable;

import com.config.EnableUser;
import com.domain.Role;
import com.domain.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

import java.util.Map;

/**
 - Import4中用法：
 - 1. 导入Bean
 - 2. 导入配置类
 - 3. 导入ImportSelector的实现类。
 - 4. 导入ImportBeanDefinitionRegistrar实现类
 */

//@Import(User.class)
//@Import(UserConfig.class)
//@Import(MyImportSelector.class)
@Import({MyImportBeanDefinitionRegistrar.class})

@SpringBootApplication
public class SpringbootEnableApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context =SpringApplication.run(SpringbootEnableApplication.class, args);
        /*//获取Bean
      	Object user = context.getBean("user");
      	System.out.println(user);*/

        /*User user = context.getBean(User.class);
      	System.out.println(user);

      	Role role = context.getBean(Role.class);
      	System.out.println(role);*/

        Object user = context.getBean("user");
      	System.out.println(user);

        /*Map<String, User> map = context.getBeansOfType(User.class);
        System.out.println(map);*/
    }
}

5.@EnableAutoConfiguration详解

@EnableAutoConfiguration 注解内部使用@Import(AutoConfigurationImportSelector.class)来加载配置类

配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载这些配置类，初始化Bean

并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean

6.自定义starter配置

需求：自定义redis-starter。要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean

步骤分析

1.创建 redis-spring-boot-autoconfigure 模块

2.创建 redis-spring-boot-starter 模块,依赖 redis-spring-boot-autoconfigure的模块

3.在 redis-spring-boot-autoconfigure 模块中初始化 Jedis 的 Bean。并定义META-INF/spring.factories 文件

4.在测试模块中引入自定义的 redis-starter 依赖，测试获取 Jedis 的Bean，操作 redis

实现

创建redis-spring-boot-starter工程

pom文件中引入redis-spring-boot-autoconfigure

XML 复制代码 
        <!--引入configure-->
        <dependency>
            <groupId>com</groupId>
            <artifactId>redis-springboot-autoconfigure</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

创建redis-spring-boot-autoconfigure配置工程

java 复制代码 
@ConfigurationProperties(prefix = "redis")
public class RedisProperties {
    private String host = "localhost";
    private int port = 6379;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }
}
java 复制代码 
package com.springbootautoconfigure;

import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    /**
     * 提供Jedis的bean
     */
    @Bean
    public RedisProperties.Jedis jedis(RedisProperties redisProperties) {
        return new RedisProperties.Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}

在resource目录下创建META-INF文件夹并创建spring.factories

java 复制代码 
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.lichee.redis.config.RedisAutoConfiguration

注意："\ "是换行使用的

在springboot-enable工程中引入自定义的redis的starter

XML 复制代码 
<!--自定义的redis的starter-->
<dependency>
    <groupId>com</groupId>
    <artifactId>redis-springboot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

在SpringbootEnableApplication启动类中测试

java 复制代码 
    Jedis jedis = context.getBean(Jedis.class);
    System.out.println(jedis);

测试springboot-enable工程中的application.properties中的配置参数

java 复制代码 
redis.port=6666

使用注解完成有条件加载配置类

java 复制代码 
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
@ConditionalOnClass(Jedis.class)
public class RedisAutoConfiguration {
    /**
     * 提供Jedis的bean
     */
    @Bean
    @ConditionalOnMissingBean(name = "jedis")
    public Jedis jedis(RedisProperties redisProperties) {
        System.out.println("RedisAutoConfiguration....");
        return new Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}

7.SpringBoot事件监听

Java中的事件监听机制

事件：Event，继承 java.util.EventObject 类的对象

事件源：Source ，任意对象Object

监听器：Listener，实现 java.util.EventListener 接口 的对象

SpringBoot 在项目启动时，会对几个监听器进行回调，我们可以实现这些监听器接口，在项目启动时完成一些操作

ApplicationContextInitializer、

SpringApplicationRunListener、

CommandLineRunner、

ApplicationRunner

java 复制代码 
package com.springbootlistener.listener;

import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer....initialize");
    }
}
java 复制代码 
package com.springbootlistener.listener;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 当项目启动后执行run方法。
 */
@Component
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner...run");
        System.out.println(Arrays.asList(args.getSourceArgs()));
    }
}
java 复制代码 
package com.springbootlistener.listener;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner...run");
        System.out.println(Arrays.asList(args));
    }
}

MyApplicationContextInitializer的使用要在resource文件夹下添加META-INF/spring.factories

java 复制代码 
org.springframework.context.ApplicationContextInitializer=com.springbootlistener.listener.MyApplicationContextInitializer
org.springframework.boot.SpringApplicationRunListener=com.springbootlistener.listener.MySpringApplicationRunListener

MySpringApplicationRunListener的使用要添加构造器

java 复制代码 
package com.springbootlistener.listener;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

public class MySpringApplicationRunListener implements SpringApplicationRunListener {
    public MySpringApplicationRunListener(SpringApplication application, String[] args) {
    }

    @Override
    public void starting() {
        System.out.println("starting...项目启动中");
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        System.out.println("environmentPrepared...环境对象开始准备");
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("contextPrepared...上下文对象开始准备");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("contextLoaded...上下文对象开始加载");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("started...上下文对象加载完成");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("running...项目启动完成，开始运行");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("failed...项目启动失败");
    }
}

8.SpringBoot流程分析-初始化

配置启动引导类（判断是否有启动主类）

判断是否是Web环境

获取初始化类、监听器类

9.SpringBoot流程分析-run

1.启动计时器

2.执行监听器

3.准备环境

4.打印banner：可以resource下粘贴自定义的banner

5.创建context

java 复制代码 
refreshContext(context);

执行refreshContext方法后才真正创建Bean

10.SpringBoot监控-actuator基本使用

监控概述

SpringBoot自带监控功能Actuator，可以帮助实现对程序内部运行情况监控，比如监控状况，Bean加载情况，配置属性，日志信息等

监控使用

1.导入依赖坐标

XML 复制代码 
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2.访问http://localhost:8080/acruator

java 复制代码 
{
    "_links":{
        "self":{
            "href":"http://localhost:8080/actuator",
            "templated":false
        },
        "health":{
            "href":"http://localhost:8080/actuator/health",
            "templated":false
        },
        "health-component-instance":{
            "href":"http://localhost:8080/actuator/health/{component}/{instance}",
            "templated":true
        },
        "health-component":{
            "href":"http://localhost:8080/actuator/health/{component}",
            "templated":true
        },
        "info":{
            "href":"http://localhost:8080/actuator/info",
            "templated":false
        }
    }
}

在application.properties中配置

java 复制代码 
info.name=zhangsan
info.age=23

http://localhost:8080/actuator/info

开启健康检查详细信息

java 复制代码 
management.endpoint.health.show-details=always
java 复制代码 
{
    "status":"UP",
    "components":{
        "diskSpace":{
            "status":"UP",
            "details":{
                "total":256048623616,
                "free":41103265792,
                "threshold":10485760,
                "exists":true
            }
        },
        "ping":{
            "status":"UP"
        }
    }
}

11.SpringBoot监控-actuator开启所有endpoint

开启所有endpoint

在application.properties中配置：

java 复制代码 
#将所有的监控endpoint暴露出来
management.endpoints.web.exposure.include=*
java 复制代码 
{
    "_links":{
        "self":{
            "href":"http://localhost:8080/actuator",
            "templated":false
        },
        "beans":{
            "href":"http://localhost:8080/actuator/beans",
            "templated":false
        },
        "caches-cache":{
            "href":"http://localhost:8080/actuator/caches/{cache}",
            "templated":true
        },
        "caches":{
            "href":"http://localhost:8080/actuator/caches",
            "templated":false
        },
        "health":{
            "href":"http://localhost:8080/actuator/health",
            "templated":false
        },
        "health-path":{
            "href":"http://localhost:8080/actuator/health/{*path}",
            "templated":true
        },
        "info":{
            "href":"http://localhost:8080/actuator/info",
            "templated":false
        },
        "conditions":{
            "href":"http://localhost:8080/actuator/conditions",
            "templated":false
        },
        "configprops":{
            "href":"http://localhost:8080/actuator/configprops",
            "templated":false
        },
        "configprops-prefix":{
            "href":"http://localhost:8080/actuator/configprops/{prefix}",
            "templated":true
        },
        "env":{
            "href":"http://localhost:8080/actuator/env",
            "templated":false
        },
        "env-toMatch":{
            "href":"http://localhost:8080/actuator/env/{toMatch}",
            "templated":true
        },
        "loggers":{
            "href":"http://localhost:8080/actuator/loggers",
            "templated":false
        },
        "loggers-name":{
            "href":"http://localhost:8080/actuator/loggers/{name}",
            "templated":true
        },
        "heapdump":{
            "href":"http://localhost:8080/actuator/heapdump",
            "templated":false
        },
        "threaddump":{
            "href":"http://localhost:8080/actuator/threaddump",
            "templated":false
        },
        "metrics-requiredMetricName":{
            "href":"http://localhost:8080/actuator/metrics/{requiredMetricName}",
            "templated":true
        },
        "metrics":{
            "href":"http://localhost:8080/actuator/metrics",
            "templated":false
        },
        "scheduledtasks":{
            "href":"http://localhost:8080/actuator/scheduledtasks",
            "templated":false
        },
        "mappings":{
            "href":"http://localhost:8080/actuator/mappings",
            "templated":false
        }
    }
}

12.SpringBoot监控-springboot admin图形化界面使用

SpringBoot Admin 是一个开源申请项目，用于管理和监控SpringBoot应用程序

Spring Boot Admin 有两个角色，客户端(Client)和服务端(Server)。

应用程序作为Spring Boot Admin Client 向为Spring Boot Admin Server注册

Spring Boot Admin Server 的UI界面将Spring Boot Admin Client 的Actuator Endpoint上的一些监控信息

创建服务端和客户端工程步骤：

admin-server：

1创建 admin-server 模块

2导入依赖坐标 admin-starter-server

XML 复制代码 
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
</dependency>

3.在引导类上启用监控功能@EnableAdminServer

java 复制代码 
package com.springbootadminserver;

import de.codecentric.boot.admin.server.config.EnableAdminServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

admin-client：

1.创建 admin-client 模块

2.导入依赖坐标 admin-starter-client

XML 复制代码 
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
</dependency>

3.配置相关信息：server地址等

server的application.properties

XML 复制代码 
server.port=9000

client的

XML 复制代码 
#执行admin.server地址
spring.boot.admin.client.url=http://localhost:9000

management.endpoint.health.show-details=always
management.endpoints.web.exposure.include=*

4.启动server和client服务，访问server

http://localhost:9000/applications

idea中也有这样的功能

13.SpringBoot部署

SpringBoot 项目开发完毕后，支持两种方式部署到服务器：

1.jar包(官方推荐)

2.war包

不修改则默认为打jar包

更改pom文件中的打包方式为war

修改启动类

java 复制代码 
package com.springbootdeploy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

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

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringbootDeployApplication.class);
    }
}

packaging改为war

XML 复制代码 
    <name>springboot-deploy</name>
    <description>springboot-deploy</description>
    <packaging>war</packaging>

指定打包的名称

XML 复制代码 
<build>
    <finalName>springboot</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

打出的war包名就为springboot

​​​​​​​

相关推荐
aircrushin20 分钟前
OpenClaw“养龙虾”现象的社会技术学分析
前端·后端
37手游后端团队26 分钟前
全网最简单！从零开始，轻松把 openclaw 小龙虾装回家
人工智能·后端·openai
用户83071968408227 分钟前
Spring Boot WebClient性能比RestTemplate高？看完秒懂！
java·spring boot
Apifox42 分钟前
测试数据终于不用到处复制了，Apifox 自动化测试新增「共用测试数据」
前端·后端·测试
Gardener1721 小时前
OpenStack Instance ID 映射机制详解
后端
无责任此方_修行中2 小时前
拒绝 AI 焦虑！一个普通程序员的真实 AI 工作流（附成本账单）
后端·程序员·ai编程
Assby2 小时前
从洋葱模型看Java与Go的设计哲学：为什么它们如此不同？
java·后端·架构
命运石之门的选择2 小时前
Flink 并行度调优"黄金三步法"
后端
泰式大师2 小时前
在 AI Agent 场景下，我们如何优雅地处理长文本？
后端
热门推荐
01GitHub 镜像站点02OpenClaw 使用和管理 MCP 完全指南03本地部署 OpenClaw + DeepSeek-R1 完全指南04OpenClaw 连接飞书完整指南：插件安装、配置与踩坑记录05OpenClaw 飞书机器人不回复消息？3 小时踩坑总结06Window 10部署openclaw报错node.exe : npm error code 12807OpenClaw 接入 QQ Bot 完整实践指南08OpenClaw macOS 完整安装与本地模型配置教程（实战版）09npm-error code 128问题解决方法10得物前端部门，没了