（超详解）SpringBoot高级部分-自动配置+监听机制+监控+项目部署

Posted LL.LEBRON

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了（超详解）SpringBoot高级部分-自动配置+监听机制+监控+项目部署相关的知识，希望对你有一定的参考价值。

文章目录

✨✨SpringBoot高级部分✨✨

该文章参考：黑马SpringBoot

基础部分的连接：
（超详解）SpringBoot初级部分-概述-01点这里
（超详解）SpringBoot初级部分-快速入门-02点这里
（超详解）SpringBoot初级部分-配置-03点这里
（超详解）SpringBoot初级部分-整合其他框架-04点这里

SpringBoot高级部分-自动配置-01

1.Condition

Condition 是在Spring 4.0 增加的条件判断功能，通过这个可以功能可以实现选择性的创建 Bean 操作。

思考：

SpringBoot是如何知道要创建哪个Bean的？比如SpringBoot是如何知道要创建RedisTemplate的？

1.1引出问题

看一个栗子：

当我们没导入redis-start时，会报错

@SpringBootApplication
public class SpringbootDemo01Application {

    public static void main(String[] args) {
        //启动SpringBoot应用，返回Spring的IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootDemo01Application.class, args);
        //获取Bean，redisTemplate
        Object redisTemplate = run.getBean("redisTemplate");
        System.out.println(redisTemplate);

    }
}

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'redisTemplate' available

当导入redis起步依赖后

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

org.springframework.data.redis.core.RedisTemplate@b7ff25

问题：

SpringBoot是怎么知道我们导入redis坐标的呢？

1.2案例

需求：

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

  1. 导入Jedis坐标后，加载该Bean，没导入，则不加载。
  2. 将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定。

自定义注解：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {

    String[] value();
}

@Configuration
public class UserConfig {

    @Bean
    //@Conditional(ClassCondition.class)
    @ConditionOnClass("redis.clients.jedis.Jedis")
    public User user(){
        return new User();
    }
}

public class ClassCondition implements Condition {

    /**
     * @param context  上下文对象，用于获取环境，ClassLoader对象
     * @param metadata 注解的元对象，可以用于注解定义的属性值
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();

        //1.需求：导入指定坐标后创建Bean
        //思路：判断指定坐标文件是否存在

        //获取注解属性值 value
        Map<String, Object> map = metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
        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;
    }
}

1.3总结

  • 自定义条件：

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

    • context：上下文对象，可以获取属性值，获取类加载器，获取BeanFactory等。
    • metadata：元数据对象，用于获取注解属性。

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

  • SpringBoot 提供的常用条件注解：

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

      @Bean
@ConditionalOnProperty(name = "itcast",havingValue = "itheima")
public User user1(){
    return new User();
}

      itcast=itheima

    • ConditionalOnClass：判断环境中是否有对应字节码文件才初始化Bean

    • ConditionalOnMissingBean：判断环境中没有对应Bean才初始化Bean

2.切换内置web服务器

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

默认：

如果要使用其他的服务器：

<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>
<!--引入相应服务器的依赖-->
<dependency>
    <artifactId>spring-boot-starter-jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

3.@Enable*注解

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

提问：SpringBoot 工程是否可以直接获取jar包中定义的Bean？

答：不可以

案例：两个子模块，①子模块要得到②子模块的User类的bean（这里用编号表示）

①导入②的依赖：

<dependency>
    <groupId>com.itheima</groupId>
    <artifactId>springboot-embal</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

①的引导类

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

@SpringBootApplication
//@ComponentScan("com.itheima.springbooyembal")
//@Import(UserConfig.class)
@EnableUser
public class SpringbootDemo01Application {

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

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

    }
}

②的配置类

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

②的自定义@EnableUser注解

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

4.@Import注解

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

  • 导入Bean 【@Import(User.classs)】

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

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

    @Import(MyImportSelector.class)

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

  • 导入 ImportBeanDefinitionRegistrar 实现类。

    @Import(MyImportBeanDefinitionRegistrar.class)

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

5.@EnableAutoConfiguration

  • @EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector.class)来加载配置类。
  • 配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载 这些配置类，初始化Bean
  • 并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean

6.案例

需求

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

实现步骤

① 创建 redis-spring-boot-autoconfigure 模块

<!--引入jedis依赖-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

② 创建 redis-spring-boot-starter 模块吗，依赖 redis-spring-boot-autoconfigure的模块

<!--引入自定义的autocongifure-->
<dependency>
    <groupId>com.ithiema</groupId>
    <artifactId>redis-spring-boot-autocongifure</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

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

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\\
  com.ithiema.redis.config.RedisAutoConfiguration

@ConfigurationProperties(prefix = "redis")
@Data
public class RedisProperties {
    private String host="localhost";
    private Integer port=6379;

}

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

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

<dependency>
    <groupId>com.itheima</groupId>
    <artifactId>redis-sping-boot-start</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

@SpringBootApplication
public class SpringbootEnablrApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootEnablrApplication.class, args);
        Jedis jedis = run.getBean(Jedis.class);
        jedis.set("name11", "xppmzz");
        System.out.println(jedis);
    }
}

SpringBoot高级部分-监听机制-02

1.Java监听机制

SpringBoot 的监听机制，其实是对Java提供的事件监听机制的封装。

Java中的事件监听机制定义了以下几个角色：

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

② 事件源：Source ，任意对象Object

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

2.SpringBoot监听机制

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

  • ApplicationContextInitializer

    @Component
public class MyApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer...initialize");
    }
}

  • SpringApplicationRunListener

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

    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        SpringApplicationRunListener.super.starting(bootstrapContext);
    }

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

    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
        SpringApplicationRunListener.super.environmentPrepared(bootstrapContext, environment);
    }

    @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...项目启动失败");

    }
}

  • CommandLineRunner

    @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));
    }
}

  • ApplicationRunner

    /**
 * 当项目启动后执行run方法：可以用于提前加载缓存redis
 */
@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()));
    }
}

其中CommandLineRunner和ApplicationRunner的实现不需要配置文件里配置东西：

要想输出的内容不为[]可以在Edit Configurations...配置：

要想ApplicationContextInitializer和SpringApplicationRunListener可以实现，必须在resources目录下的META-INF文件夹下的配置spring.factories（名字必须一致，这样spring才能扫描到）：

org.springframework.context.ApplicationContextInitializer=com.itheima.springbootlistener.listener.MyApplicationContextInitializer
#所继承类的全类名=实现类的全类名
org.springframework.boot.SpringApplicationRunListener=com.itheima.springbootlistener.listener.MySpringApplicationRunListener

SpringBoot高级部分-监控-03

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

1.使用步骤

① 导入依赖坐标

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

② 访问http://localhost:8080/actuator

2.SpringBoot 监控使用

路径描述
/beans描述应用程序上下文里全部的Bean，以及它们的关系
/env获取全部环境属性
/env/{name}根据名称获取特定的环境属性值
/health报告应用程序的健康指标，这些值由HealthIndicator的实现类提供
/info获取应用程序的定制信息，这些信息由info打头的属性提供
/mappings描述全部的URI路径，以及它们和控制器(包含Actuator端点)的映射关系
/metrics报告各种应用程序度量信息，比如内

以上是关于（超详解）SpringBoot高级部分-自动配置+监听机制+监控+项目部署的主要内容，如果未能解决你的问题，请参考以下文章

（超详解）SpringBoot初级部分-概述-01

（超详解）SpringBoot初级部分-概述-01

（超详解）SpringBoot初级部分-整合其他框架-04

（超详解）SpringBoot初级部分-快速入门-02

SpringBoot开发实用篇复习1

超详细，新手都能看懂 ！SpringBoot高级笔记(全彩版)让阿里老爸带你飞~

(c)2006-2024 SYSTEM All Rights Reserved IT常识