【Spring框架家族】SpringBoot自动配置基本实现

SpringBoot自动配置-Condition_1

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

@Conditional要配和Condition的实现类（ClassCondition）进行使用

• ClassCondition

 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
        /*
        * 该注解标记在创建Bean实例方法上
        * 通过条件结果，判断是否创建Bean实例
        * 条件结果是由属性决定的
        * 属性是一个类，需要实现接口Condition，重写matches方法，返回一个boolean值
        */
        @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);
        }
    }

SpringBoot自动配置-Condition_2

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

自定义条件注解类

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

注意：此处@ConditionOnClass为自定义注解

    @Configuration
    public class UserConfig {
    
        @Bean
        //@Conditional(ClassCondition.class)
        @ConditionOnClass("com.alibaba.fastjson.JSON")
        public User user(){
            return new User();
        }
    
        @Bean
        @ConditionalOnProperty(name = "赵丽颖",havingValue = "廊坊")
        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);
    
        }
    
    }

SpringBoot 提供的常用条件注解：

• ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化Bean
• ConditionalOnClass：判断环境中是否有对应字节码文件才初始化Bean
• ConditionalOnMissingBean：判断环境中没有对应Bean才初始化Bean

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

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

查看继承关系图

排除Tomcat

pom文件中的排除依赖效果

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

SpringBoot自动配置-Enable注解原理

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

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

演示代码：

springboot-enable工程

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

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

SpringBoot自动配置-@Import详解

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

• 导入Bean @Import(User.class)只能导入一个Bean，如果有多个Bean，则需要使用多个@Import注解，不方便
• 导入配置类 @Import(UserConfig.class)可以在配置类中配置多个Bean，只需要使用@Import注解导入配置类即可，等同于spring中的配置文件
• 导入 ImportSelector 实现类 @Import(MyImportSelector.class) 使用ImportSelector接口中的方法 selectImports ，可以假装要创建Bean的全类名，返回值为String[]。
• 导入 ImportBeanDefinitionRegistrar 实现类。 @Import({MyImportBeanDefinitionRegistrar.class}) 使用ImportBeanDefinitionRegistrar接口中的registerBeanDefinitions方法去创建Bean实例，并且指定Bean的ID，Bean实例的创建工作由BeanDefinitionRegistry 参数调用 registerBeanDefinition 完成Bean的

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

    public class MyImportSelector implements ImportSelector {
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return new String[]{"cs.wy.domain.User", "cs.wy.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);
        }
    }

SpringbootEnableApplication测试代码

 /**
    * 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);
        }  
    }

SpringBoot自动配置-@EnableAutoConfiguration详解

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

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

SpringBoot自动配置-自定义starter步骤分析

SpringBoot自动配置-自定义starter实现-1

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

     		<!--引入configure，自己编写的redis的自动化配置-->
            <dependency>
                <groupId>com.itheima</groupId>
                <artifactId>redis-spring-boot-autoconfigure</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>

2.创建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;
        }
    }

创建RedisAutoConfiguration自动配置类

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

在resource目录下创建META-INF文件夹并创建spring.factories，注意：”\ “是换行使用的

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
      cs.wy.redis.config.RedisAutoConfiguration

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

      		<!--自定义的redis的starter-->
            <dependency>
                <groupId>com.itheima</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自动配置-自定义starter实现-2

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

    redis.port=6666

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

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