springboot（4.3）自动装配

springboot自动装配

springboot是一个以spring framework为基础，用于快速构建应用程序的框架。
也就是说springboot拥有springframework的所有功能，并自己还提供了一系列用于简化配置、自动装配等功能。
其中，自动装配个人认为是springboot框架的核心，本文主要学习和总结下springboot的自动装配功能和自定义starter。

利用springboot搭建一个spring+mybatis的web项目

1. 配置pom.xml文件

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--引入springboot版本-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.12.RELEASE</version>
    </parent>
    <groupId>com.msxf.study.spring</groupId>
    <artifactId>spring-study</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
    <!--引入spring web starter-->
    <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <!--引入mybatis starter-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.2</version>
    </dependency>
    <!--引入mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
</dependencies>
</project>

2. 编写springboot配置文件

spring:
  datasource:
    url: jdbc:mysql://192.168.1.250:3306/test
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver

3. 编写Java代码实现对数据库的增删改查

@Data
public class UserPO {
    private String id;
    private String userName;
    private String password;
}
@Mapper
public interface UserMapper {
    @Select("select id,user_name as userName from aimas_sys_user")
    List<UserPO> findAll();
}
@Component
@Transactional
public class UserServiceImpl{
    @Resource
    private UserMapper userMapper;
    public List<UserPO> findAll(){
        return userMapper.findAll();
    }
}
@RestController
public class UserController {
    @Resource
    private UserServiceImpl userService;
    @RequestMapping("findAll")
    public List<UserPO> findAll(){
        return userService.findAll();
    }
}
@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        new SpringApplication().run(Main.class,args);
    }
}

就这样我们就搭建好了一个基于mybatis的springboot的web应用，so easy！

springboot + mybatis 的自动装配

能如此方便快捷的实现一个基于mybatis的springboot web应用，最大功臣就是springboot的自动装配。
如果不使用springboot的自动装配，我们要实现这些功能，至少需要做到如下2件事：

1. 引入spring、mybatis以及其他各种包的相关依赖
2. 需要在application.xml中配置很多bean，如dataSource、transactionManager等等

那么在背后，springboot是如何做到的呢？
需要从@SpringBootApplication注解开始看起，这个注解搞定了很多事

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration 
@EnableAutoConfiguration  //开启自动配置
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
  @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication


@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)  //自动配置注解又引入了AutoConfigurationImportSelector类
public @interface EnableAutoConfiguration

@Import注解，其作用是将相关类注入到spring的beanFactory中，使其成为springbean：其值可以为如下三种：

1. 具体的Java类，如@Import({xxx1.class,xx2.class})，表示直接引入一个或多个类，
   对应的import的bean都将加入到spring容器中，这些在容器中bean名称是该类的全类名 ，比如com.xxx1

2. ImportSelector的实现类，如@Import(MyImportSelector.class})，这种方式比较常用
   需要自定义类实现ImportSelector接口，并重新方法selectImports，该方法的返回值为要导入到容器中的bean全类名

3. ImportBeanDefinitionRegistrar的实现类，如@Import(MyImportBeanDefinitionRegistrar.class})
   需要自定义类实现ImportBeanDefinitionRegistrar接口，并重新方法registerBeanDefinitions，在方法中需要自定义要引入对象的BeanDefinition对象，并将BeanDefinition对象注册到spring的beanFactory中去

理解了@Import注解后，继续看源码

AutoConfigurationImportSelector
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
  if (!isEnabled(annotationMetadata)) {
   return NO_IMPORTS;
  }
  AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
    .loadMetadata(this.beanClassLoader);
  AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
    annotationMetadata);
  return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
 }

这里是用SpringFactoriesLoader.loadFactoryNames()扫描所有具有META-INF/spring.factories的jar包，并将文件内容读取。
如mybatis-spring-boot-autoconfigure:xx.jar里的spring.factories文件的内容为：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

这样当这个文件被解析后，会去加载和解析类MybatisAutoConfiguration，而MybatisAutoConfiguration类的代码如下所示：

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisAutoConfiguration {
    //省略其他
    @Bean
      @ConditionalOnMissingBean
      public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        //省略其他
        return factory.getObject();
      }
      //省略其他
}

可以看到，在MybatisAutoConfiguration类中，有我们熟悉的SqlSessionFactory等对象。

注解解释

在MybatisAutoConfiguration类中，有@ConditionalOnClass、@ConditionalOnBean、@EnableConfigurationProperties、@ConditionalOnMissingBean等各种注解，
这些注解叫条件依赖注解，springboot提供了如下的条件依赖注解：

1. @ConditionalOnClass：表示应用中包含某个类时，对应的配置才生效，
   如@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })，表示程序中必须有SqlSessionFactory和SqlSessionFactoryBean这个类，
   那么这个MybatisAutoConfiguration配置类才进一步加载和解析
2. @ConditionalOnMissingClass：表示应用中不包含某个类时，对应的配置才生效
3. @ConditionalOnMissingBean：表示spring中不存在指定bean时，对应的配置才生效，如上述代码中，表示SqlSessionFactory类的springbean不存在，才执行sqlSessionFactory这个方法
4. @ConditionalOnBean：表示spring中存在指定bean时，对应的配置才生效，如@ConditionalOnBean(DataSource.class)
   表示应用中存在DataSource的springbean时，这个MybatisAutoConfiguration配置类才进一步加载和解析
5. @ConditionalOnProperty：表示指定的参数值符合要求时，对应的配置才生效
6. @ConditionalOnResource：表示指定的资源存在时，对应的配置才生效
7. @ConditionalOnWebApplication：当前处于web环境时，对应的配置才生效
8. @ConditionalOnNotWebApplication：当前处于非web环境时，对应的配置才生效
9. @ConditionalOnExpression：指定的参数符合要求时，对应的配置才生效，和@ConditionalOnProperty的区别是，这个注解的参数可以使用springEL表达式

注意：如果多个条件注解共同修饰一个对象时，那么多个注解是并且（类似sql中的and关系）的关系，只有都满足，对应的配置才生效

springboot还提供了几个先后顺序的注解，如下所示：

1. @AutoConfigureAfter：在指定配置类之后在加载，如上述代码中的@AutoConfigureAfter(DataSourceAutoConfiguration.class)
   表示MybatisAutoConfiguration配置需要在DataSourceAutoConfiguration配置加载后才能加载
2. @AutoConfigureBefore：在指定配置类之前加载
3. @AutoConfigureOrder：指定该配置类的加载顺序，默认值为0

springboot+mybatis自动装配的过程总结：

1. 在springboot应用的启动类上，加上注解 @SpringBootApplication
2. SpringBootApplication注解会去读取 应用中所有jar包中包含META-INF/spring.factories配置文件，获取到对应的key和value，key表示一种注解，value表示该注解对应的配置类，如mybatis的自动装配注解EnableAutoConfiguration，对应的值为MybatisAutoConfiguration类
3. 获取注解对应的配置类，如mybatis的自动装配注解EnableAutoConfiguration对应的MybatisAutoConfiguration类，解析该类，如果满足条件
   则进行相关的配置加载，否则就跳过相关配置

自定义starter

在了解了springboot+mybatis的自动装配后，我们可以模拟生成自己的starter类，如下知识就是如何生成自己的starter。

假设公司有一套自己的权限验证框架，该框架的jar包为：com.my.auth:my-auth:1.0.0.jar

1. 利用IDEA等工具生成一个maven项目，如myauth-spring-boot-autoconfigure，在pom.xml中加入com.my.auth:my-auth:1.0.0.jar依赖
2. 利用IDEA等工具生成一个maven项目，如myauth-spring-boot-starter，在pom.xml中加入myauth-spring-boot-autoconfigure依赖

自动装配逻辑编写

在myauth-spring-boot-autoconfigure项目中，我们需要做如下几件事：

编写自定义注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(MyImport.class)
public @interface MyAutoConfig {
}

编写自定义加载器

public class MyImport implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //去META-INFO/spring.factories文件中读取数据
        //第一个参数为META-INFO/spring.factories文件中对应的key，即注解类全路径名
        List<String> list = SpringFactoriesLoader.loadFactoryNames(MyAutoConfig.class, MyImport.class.getClassLoader());
        return StringUtils.toStringArray(list);
    }
}

编写自定义配置类

定义满足什么条件才能加载哪些类，这个需要根据具体的业务逻辑来，如下只是伪代码。

@Configuration
@ConditionalOnClass({xxx.class})
@EnableConfigurationProperties(MyProperties.class) //表示需要在spring的配置文件中配置相关数据
public class MyConfig {

    @Bean
    public XXX xxx(@Autowired YYY yyy){
        XXX xx = new XXX();
        xx.setYY(yyy);
        return xx;
    }
}

编写starter需要的配置类，如果不需要在配置文件配置参数，这个步骤可以省略

@ConfigurationProperties(prefix = "myauth")
@Data
public class MyProperties {
    private String userName;
    private String password;
}
//表示需要在spring的配置文件中，如application.properties中配置如下选项：
//myauth.userName=xxx
//myauth.password=yyy

在META-INF/spring.factories文件中编写配置

这步需要和第二步关联起来

com.study.spring.config.MyAutoConfig=\
com.study.spring.config.MyConfig

最后将本项目进行打包，并上传到maven仓库

自定义starter项目编写

这就是一个只包含了pom文件的jar包，在pom.xml中加入自动装配逻辑项目的依赖，最后将starter项目也打包上传到maven仓库中

自定义starter的使用

在项目的pom中，加入我们自定义的starter依赖，在项目启动类上加上@MyAutoConfig注解，然后就可以使用相关的功能了。