SpringBoot进阶篇之自动配置解析-自定义类配置-启动流程-项目部署

最新推荐文章于 2023-12-07 08:39:51 发布

韩_师兄

最新推荐文章于 2023-12-07 08:39:51 发布

阅读量877

点赞数 2

分类专栏： Spring 文章标签： spring boot spring java

本文链接：https://blog.csdn.net/ABestRookie/article/details/108210360

版权

Spring 专栏收录该内容

39 篇文章 1 订阅

订阅专栏

1. SpringBoot自动配置解析

1.1 需求:在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：导入Jedis坐标后，加载该Bean，没导入，则不加载.

首先创建一个User类

@Component
public class User{
}

在入口类中

@SpringBootApplication
public class SpringbootConditionApplication {
	public static void main(String[] args) {
		ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
        Object user = context.getBean("user");
        System.out.println(user);
    }
}

总结:发现都可以访问到user对象，不需要任何条件限制，但是我们的要求是导入jedis后才可以加载。

1.2 加入jedis后,@Conditional要配和Condition的实现类（ClassCondition）进行使用.

定义ClassCondition，实现Condition接口类

public class ClassCondition implements Condition {
    /**
     *
     * @param context 上下文对象。用于获取环境，IOC容器，ClassLoader对象
     * @param metadata 注解元对象。 可以用于获取注解定义的属性值
     * @return
     */
    @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;
    }
}

添加UserConfig

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

测试

@SpringBootApplication
public class SpringbootConditionApplication {

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

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

    }
}

1.3 需求：将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定

自定义条件注解类

import org.springframework.context.annotation.Conditional;
import java.lang.annotation.*;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class) //此处@ConditionOnClass为自定义注解
public @interface ConditionOnClass {
    String[] value();
}

@Configuration
public class UserConfig {

    @Bean
    //@Conditional(ClassCondition.class)
    @ConditionOnClass("com.alibaba.fastjson.JSON")
    public User user(){
        return new User();
    }

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

}

测试User对象的创建

@SpringBootApplication
public class SpringbootConditionApplication {

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

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

}

总结:

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

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

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

1.4 SpringBoot自动配置-切换内置web服务器

内置四种web服务器:

1.Tomcat 2.Netty 3.Jetty 4.Undertow

 		<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>

1.5 SpringBoot自动配置-Enable注解原理

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

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

springboot-enable工程

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

//@ComponentScan("com.cf.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

 		<dependency>
            <groupId>com.cf</groupId>
          <artifactId>springboot-enable-other</artifactId>
            <version>0.0.1-SNAPSHOT</version>
      </dependency>

springboot-enable-other工程
UserConfig

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

  
  **EnableUser注解类**
  
  ```java
  import org.springframework.context.annotation.Import;
  import java.lang.annotation.*;
  
  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Import(UserConfig.class)
  public @interface EnableUser {
}

总结:

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

三种解决方案：

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

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

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

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

1.6 SpringBoot自动配置-@Import详解

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

①导入Bean @Import(User.class)

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

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

④导入 ImportBeanDefinitionRegistrar 实现类

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

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

1.7 SpringBoot自动配置-@EnableAutoConfiguration详解

@EnableAutoConfiguration中使用的是第三种方式：@Import(AutoConfigurationImportSelector.class)

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

2 配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载这些配置类，初始化Bean ; 并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean.

1.8 入门案例之自定义starter步骤分析

1.8.1 需求: 自定义redis-starter,要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean.

1.8.2 步骤分析:

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.

1.8.3 详细步骤:

创建redis-spring-boot-starter工程, pom文件中引入redis-spring-boot-autoconfigure

 <!--引入configure-->
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>redis-spring-boot-autoconfigure</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

创建redis-spring-boot-autoconfigure配置工程 ,创建RedisProperties配置文件参数绑定类

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

2.1 创建RedisAutoConfiguration自动配置类

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {

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

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

<!--注意：”\ “是换行使用的   有多个自动配置类使用,\分隔-->
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.cf.redis.config.RedisAutoConfiguration

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

  <!--自定义的redis的starter-->
        <dependency>
            <groupId>com.cf</groupId>
            <artifactId>redis-spring-boot-starter</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

在SpringbootEnableApplication启动类中测试

 		Jedis jedis = context.getBean(Jedis.class);
        System.out.println(jedis);

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

redis.port=6666

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

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

1.9 SpringBoot事件监听

事件：Event，继承 java.util.EventObject 类的对象
事件源：Source ，任意对象Object
监听器：Listener，实现 java.util.EventListener 接口的对象

SpringBoot中四大监听器:
a. ApplicationContextInitializer
b. SpringApplicationRunListener
c. CommandLineRunner
d. ApplicationRunner

注意:
自定义监听器的启动时机：MyApplicationRunner和MyCommandLineRunner都是当项目启动后执行，使用@Component放入容器即可使用.

1.9.1 ApplicationRunner

/**
 * 当项目启动后执行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()));
    }
}

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

1.9.3 ApplicationContextInitializer

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

org.springframework.context.ApplicationContextInitializer=com.itheima.springbootlistener.listener.MyApplicationContextInitializer

实现ApplicationContextInitializer接口方法,ApplicationContext初始化执行.

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

1.9.4 SpringApplicationRunListener

SpringApplicationRunListener的使用要添加构造器

public class MySpringApplicationRunListener implements SpringApplicationRunListener {

	//构造器,不添加,会报错,反馈没有init方法
    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...项目启动失败");
    }
}

2.0 SpringBoot流程分析-初始化

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

2. 判断是否是Web环境

3. 获取初始化类、监听器类

在这里插入图片描述

2.1 SpringBoot流程分析-run

1. 启动计时器
2. 执行监听器
3. 准备环境
4. 打印banner：可以resource下粘贴自定义的banner
5. 创建context, refreshContext(context) , 执行refreshContext方法后才真正创建Bean
在这里插入图片描述

2.2 SpringBoot监控-actuator基本使用

1.在pom.xml中导入坐标(版本跟随父模块)

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

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

2.1 在application.properties中配置,使用http://localhost:8080/actuator/info访问

info.name=rose
info.age=19

2.2 在application.properties中配置,开启健康检查详细信息,

management.endpoint.health.show-details=always

{
    "status":"UP",
    "details":{
        "diskSpace":{
            "status":"UP",
            "details":{
                "total":159579508736,
                "free":13558104064,
                "threshold":10485760
            }
        },
        "redis":{
            "status":"UP",
            "details":{
                "version":"2.4.5"
            }
        }
    }
}

2.3 SpringBoot监控-actuator开启所有endpoint
在application.properties中配置：

management.endpoints.web.exposure.include=*

2.3 SpringBoot部署

2.3.1 jar包(官方推荐)

springboot项目默认打包为jar,在命令行使用:

java -jar jar包名

2.3.2 war包

1.在pom.xml中指定打包方式为war
2. 在pom.xml中,安装maven-plugin,指定打包的名称

 <build>
        <finalName>springboot</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

修改启动类, 继承SpringBootServletInitializer,重写configure方法

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;

//为了生成war包,继承SpringBootServletInitializer,重写configure方法
@SpringBootApplication
public class SpringbootDeployApplication extends SpringBootServletInitializer {

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

	//重写configure方法
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringbootDeployApplication.class);
    }
}

韩_师兄

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
SpringBoot进阶篇之自动配置解析-自定义类配置-启动流程-项目部署

1. SpringBoot自动配置解析1.1 需求:在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：导入Jedis坐标后，加载该Bean，没导入，则不加载.首先创建一个User类@Componentpublic class User{}在入口类中@SpringBootApplicationpublic class SpringbootConditionApplication { public static void main(String[] args
复制链接

扫一扫

专栏目录