SpringBoot原理

一、Bean原理

1、配置文件的优先级

SpringBoot项目当中支持的三类配置文件：
​
- application.properties
- application.yml
- application.yaml
配置文件优先级排名（从高到低）：
1. properties配置文件
2. yml配置文件
3. yaml配置文件
  
    虽然springboot支持多种格式配置文件，但是在项目开发时，推荐统一使用一种格式的配置。（yml是主流）
    
SpringBoot还支持另外两种常见的配置方式：
    1. Java系统属性配置 （格式： -Dkey=value）
    2. 命令行参数 （格式：--key=value）
    
优先级： 命令行参数 >  系统属性参数 > properties参数 > yml参数 > yaml参数
​
验证优先级
先进行打包程序
   1. 执行maven打包指令package，把项目打成jar文件
   2. 使用命令：java -jar 方式运行jar文件程序
    注意事项： 
    Springboot项目进行打包时，需要引入插件 spring-boot-maven-plugin (基于官网骨架创建项目，会自动添加该插件)
 在命令窗口中进行输入命令进行验证
- java系统属性（-Dxxx=xxx）
- 命令行参数（--xxx=xxx）

2、Bean对象管理

    Spring当中提供的注解@Component以及它的三个衍生注解（@Controller、@Service、@Repository）来声明IOC容器中的bean对象，同时也提供了为应用程序注入运行时所需要依赖的bean对象，也就是依赖注入DI。
        
获取Bean对象
    3种常用方式：
        1、根据name获取bean
          Object getBean(String name)
        
        2、根据类型获取bean
          <T> T getBean(Class<T> requiredType)
        
        3、根据name获取bean（带类型转换）
          <T> T getBean(String name, Class<T> requiredType)
 
 /********************************************************************/
@SpringBootTest
class SpringbootWebConfig2ApplicationTests {
​
    @Autowired
    private ApplicationContext applicationContext; //获取IOC容器对象
​
    //获取bean对象
    @Test
    public void testGetBean(){
        //根据bean的名称获取
        DeptController bean1 = (DeptController) applicationContext.getBean("deptController");
        System.out.println(bean1);
​
        //根据bean的类型获取
        DeptController bean2 = applicationContext.getBean(DeptController.class);
        System.out.println(bean2);
​
        //根据bean的名称 及 类型获取
        DeptController bean3 = applicationContext.getBean("deptController", DeptController.class);
        System.out.println(bean3);
    }
}
        
    从IOC容器当中来获取到bean对象，需要先拿到IOC容器对象，默认情况下，IOC中的bean对象是单例）
​
​

3、Bean的作用域

 在Spring中支持五种作用域，后三种在web环境才生效：
   作用域                   说明
 singleton            容器内同名称的bean只有一个实例（单例）（默认）
 prototype            每次使用该bean时会创建新的实例（非单例）
 request              每个请求范围内会创建新的实例（web环境中，了解）
 session              每个会话范围内会创建新的实例（web环境中，了解）
 application          每个应用范围内会创建新的实例（web环境中，了解）
    
   可以借助Spring中的@Scope注解来进行配置作用域
//默认bean的作用域为：singleton (单例)
@Scope("prototype") //bean作用域为非单例 prototype的bean，每一次使用该bean的时候都会创建一个新的实例
实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性,一般我们使用prorotype的场景很少，但是如果需要用到，要使用手动获取而不能用autowired注入。
@Lazy //延迟加载（第一次使用bean对象时，才会创建bean对象并交给ioc容器管理）  

4、第三方Bean

   在我们项目开发当中，还有一种情况就是这个类它不是我们自己编写的，而是我们引入的第三方依赖当中提供的。
   例如：dom4j就是第三方组织提供的。  dom4j中的SAXReader类就是第三方编写的。
<!--Dom4j-->
<dependency>
    <groupId>org.dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>2.1.3</version>
</dependency>    
按照我们之前的做法，需要在SAXReader类上添加一个注解@Component（将当前类交给IOC容器管理），第三方提供的类是只读的。无法在第三方类上添加@Component注解或衍生注解。
    如果要管理的bean对象来自于第三方（不是自定义的），是无法用@Component 及衍生注解声明bean的，就需要用到**@Bean**注解。
       
**解决方案1：在启动类上添加@Bean标识的方法**
@SpringBootApplication
public class SpringbootWebConfig2Application {
​
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
​
    //声明第三方bean
    @Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean
    public SAXReader saxReader(){
        return new SAXReader();
    }
}
解决方案2：在配置类中定义@Bean标识的方法
    如果需要定义第三方Bean时， 通常会单独定义一个配置类
@Configuration //配置类  (在配置类当中对第三方bean进行集中的配置管理)
public class CommonConfig {
​
    //声明第三方bean
    @Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean
          //通过@Bean注解的name/value属性指定bean名称, 如果未指定, 默认是方法名
    public SAXReader reader(DeptService deptService){
        System.out.println(deptService);
        return new SAXReader();
    }
​
}
​
注意事项 ：
- 通过@Bean注解的name或value属性可以声明bean的名称，如果不指定，默认bean的名称就是方法名。
- 如果第三方bean需要依赖其它bean对象，直接在bean定义方法中设置形参即可，容器会根据类型自动装配。
    
    Bean大家只需要保持一个原则：
如果是在项目当中我们自己定义的类，想将这些类交给IOC容器管理，我们直接使用@Component以及它的衍生注解来声明就可以。
    

二、SpringBoot原理

   虽然Spring是目前世界上最流行的Java框架，但如果我们直接基于Spring框架进行项目的开发，会比较繁琐。
    繁琐主要体现在两个地方：
       1. 在pom.xml中依赖配置比较繁琐，在项目开发时，需要自己去找到对应的依赖，还需要找到依赖它所配套的依赖以及对应版本，否则就会出现版本冲突问题。
       2. 在使用Spring框架进行项目开发时，需要在Spring的配置文件中做大量的配置，这就造成Spring框架入门难度较大，学习成本较高。
    基于Spring存在的问题，官方在Spring框架4.0版本之后，又推出了一个全新的框架：SpringBoot。通过 SpringBoot来简化Spring框架的开发(是简化不是替代)。我们直接基于SpringBoot来构建Java项目，会让我们的项目开发更加简单，更加快捷。
       
      ※ 重点：※
        通过SpringBoot所提供的起步依赖，就可以大大的简化pom文件当中依赖的配置，从而解决了Spring框架当中依赖配置繁琐的问题。
        通过自动配置的功能就可以大大的简化框架在使用时bean的声明以及bean的配置。我们只需要引入程序开发时所需要的起步依赖，项目开发时所用到常见的配置都已经有了，我们直接使用就可以了。

1、起步依赖

Spring Boot的起步依赖（Starter Dependency）是一组预配置的依赖项，用于快速创建和配置一个特定功能的应用程序。这些起步依赖简化了依赖管理和版本控制，以及配置的繁琐过程。
​
Spring Boot提供了许多官方定义的起步依赖，每个起步依赖都提供了特定功能的开箱即用配置。比如：
​
- `spring-boot-starter-web`：用于构建基于Web的应用程序，包括Spring MVC、Tomcat容器等。
- `spring-boot-starter-data-jpa`：用于访问和操作关系型数据库的应用程序，包括Spring Data JPA、Hibernate等。
- `spring-boot-starter-security`：用于添加安全认证和授权机制的应用程序，包括Spring Security等。
- `spring-boot-starter-test`：用于在应用程序进行单元测试和集成测试时所需的测试框架，包括JUnit、Mockito等。
​
你可以在你的Spring Boot项目中使用这些起步依赖，通过添加它们到你的项目的依赖管理工具（如Maven或Gradle）的配置文件中。例如，在使用Maven时，可以在`pom.xml`文件中添加以下依赖项配置：
​
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- 其他起步依赖 -->
</dependencies>
​
导入起步依赖后，你无需手动配置依赖项的版本或相关的配置项，Spring Boot会自动进行自动配置（Auto-Configuration）。你可以根据需要修改和定制这些自动配置。
​
通过使用Spring Boot的起步依赖，可以快速搭建和配置一个功能丰富的Spring Boot应用程序，节省了需要手动管理依赖和配置的时间和精力。
    
//   ※总结※ ： 起步依赖的原理就是Maven的依赖传递
    

2、自动配置

   自动配置（Auto-Configuration）是Spring Boot的一个核心特性，它通过约定大于配置的原则，自动为应用程序进行配置。自动配置的目标是尽可能地减少开发人员的配置工作，让开发人员能够更专注于业务逻辑的实现。
​
    在Spring Boot中，自动配置是通过条件化配置（Conditional Configuration）实现的。Spring Boot会根据应用程序的类路径、已有的配置和其他条件来判断需要自动配置哪些组件和功能。当满足特定条件时，Spring Boot会自动应用相应的配置。
​
    自动配置的好处是可以减少开发人员的配置工作量，提高开发效率。开发人员只需要添加相应的起步依赖，Spring Boot就会根据依赖的类型和配置自动进行配置。如果需要修改自动配置的行为，可以通过自定义配置来覆盖默认的自动配置。
​
    自动配置在Spring Boot中广泛应用于各个模块和功能，包括Web开发、数据库访问、安全认证、消息队列等。通过自动配置，开发人员可以快速搭建一个功能完善的应用程序，同时也可以根据需要进行定制和扩展。

3、第三方Bean的自动装配方法

    如果这个类它不是我们自己定义的，而是引入的第三方依赖当中提供的类，而且我们还想将这个类交给IOC容器管理。此时我们就需要在配置类中定义一个方法，在方法上加上一个@Bean注解，通过这种方式来声明第三方的bean对象。
  
  在类上添加@Component注解来声明bean对象时，还需要保证@Component注解能被Spring的组件扫描到。
  SpringBoot项目中的@SpringBootApplication注解，具有包扫描的作用，但是它只会扫描启动类所在的当前包以及子包。
    
    
※重点※ ：那么如何解决以上问题的呢？
    
※方案1※ ：@ComponentScan 组件扫描
    
@SpringBootApplication
@ComponentScan({"com.itheima","com.example"}) //指定要扫描的包
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}
缺点：
1. 使用繁琐
2. 性能低
/**************************************************************************************************/
※方案2※ ：
    @Import 导入（使用@Import导入的类会被Spring加载到IOC容器中）
导入形式主要有以下几种：
​
1. 导入普通类
2. 导入配置类
3. 导入ImportSelector接口实现类
    
&&& 1). 使用@Import导入普通类：
@Import(TokenParser.class) //导入的类会被Spring加载到IOC容器中
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}
/**************************************************************************************************/
&&& 2). 使用@Import导入配置类：
    
配置类
@Configuration
public class HeaderConfig {
    @Bean
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
​
    @Bean
    public HeaderGenerator headerGenerator(){
        return new HeaderGenerator();
    }
}   
​
启动类
@Import(HeaderConfig.class) //导入配置类
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}
​
测试类
@SpringBootTest
public class AutoConfigurationTests {
    @Autowired
    private ApplicationContext applicationContext;
​
    @Test
    public void testHeaderParser(){
        System.out.println(applicationContext.getBean(HeaderParser.class));
    }  
     @Test
    public void testHeaderGenerator(){
        System.out.println(applicationContext.getBean(HeaderGenerator.class));
    }
    
    //省略其他代码...
}
/**************************************************************************************************/
&&& 3). 使用@Import导入ImportSelector接口实现类：
ImportSelector接口实现类
public class MyImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //返回值字符串数组（数组中封装了全限定名称的类）
        return new String[]{"com.example.HeaderConfig"};
    }
}
​
启动类
@Import(MyImportSelector.class) //导入ImportSelector接口实现类
@SpringBootApplication
public class SpringbootWebConfig2Application {
​
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}
/**************************************************************************************************/
怎么让第三方依赖自己指定bean对象和配置类？
​
- 比较常见的方案就是第三方依赖给我们提供一个注解，这个注解一般都以@EnableXxxx开头的注解，注解中封装的就是@Import注解
​
    
&&& 4). 使用第三方依赖提供的 @EnableXxxxx注解
  第三方依赖中提供的注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportSelector.class)//指定要导入哪些bean对象或配置类
public @interface EnableHeaderConfig { 
}
​
在使用时只需在启动类上加上@EnableXxxxx注解即可
@EnableHeaderConfig  //使用第三方依赖提供的Enable开头的注解
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}
第4种方式会更方便更优雅，而这种方式也是SpringBoot当中所采用的方式。

4、自动配置的原理

要搞清楚SpringBoot的自动配置原理，要从SpringBoot启动类上使用的核心注解@SpringBootApplication开始分析：
在@SpringBootApplication注解中包含了：
- 元注解（不再解释）
- @SpringBootConfiguration  //表示配置类
- @EnableAutoConfiguration  //Enable开头的注释
- @ComponentScan    //组件扫描
- @Indexed 
    
@SpringBootConfiguration注解上使用了@Configuration，表明SpringBoot启动类就是一个配置类。
@Indexed注解，是用来加速应用启动的（不用关心）。
    
@ComponentScan注解是用来进行组件扫描的，扫描启动类所在的包及其子包下所有被@Component及其衍生注解声明的类。
SpringBoot启动类，之所以具备扫描包功能，就是因为包含了@ComponentScan注解。
    
&重点&： @EnableAutoConfiguration注解（自动配置核心注解）：使用@Import注解，导入了实现ImportSelector接口的实现类。
AutoConfigurationImportSelector类是ImportSelector接口的实现类。AutoConfigurationImportSelector类中重写了ImportSelector接口的selectImports()方法：
    selectImports()方法底层调用getAutoConfigurationEntry()方法，获取可自动配置的配置类信息集合
    getAutoConfigurationEntry()方法通过调用getCandidateConfigurations(annotationMetadata, attributes)方法获取在配置文件中配置的所有自动配置类的集合
    getCandidateConfigurations方法的功能：
    获取所有基于META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件、META-INF/spring.factories文件中配置类的集合
    META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件和META-INF/spring.factories文件这两个文件在哪里呢？
- 通常在引入的起步依赖中，都有包含以上两个文件
在META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports配置文件中指定了第三方依赖Gson的配置类：GsonAutoConfiguration
  第三方依赖中提供的GsonAutoConfiguration类： 
    在GsonAutoConfiguration类上，添加了注解@AutoConfiguration，通过查看源码，可以明确：GsonAutoConfiguration类是一个配置。
    从而可以看出自动配置原理：就是在配置类中定义一个@Bean标识的方法，而Spring会自动调用配置类中使用@Bean标识的方法，并把方法的返回值注册到IOC容器中。
/**********************************************************************************************************/
**自动配置源码小结**
​
   自动配置原理源码入口就是@SpringBootApplication注解，在这个注解中封装了3个注解，分别是：
​
- @SpringBootConfiguration
  - 声明当前类是一个配置类
- @ComponentScan
  - 进行组件扫描（SpringBoot中默认扫描的是启动类所在的当前包及其子包）
- @EnableAutoConfiguration
  - 封装了@Import注解（Import注解中指定了一个ImportSelector接口的实现类）
    - 在实现类重写的selectImports()方法，读取当前项目下所有依赖jar包中META-INF/spring.factories、META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports两个文件里面定义的配置类（配置类中定义了@Bean注解标识的方法）。
    
    &注意&： 在声明bean对象时，上面有加一个以@Conditional开头的注解，这种注解的作用就是按照条件进行装配，只有满足条件之后，才会将bean注册到Spring的IOC容器中。

5、 @Conditional

@Conditional注解：
    作用：按照一定的条件进行判断，在满足给定条件后才会注册对应的bean对象到Spring的IOC容器中。
    - 位置：方法、类
  - @Conditional本身是一个父注解，派生出大量的子注解：
  - @ConditionalOnClass：判断环境中有对应字节码文件，才注册bean到IOC容器。
  - @ConditionalOnMissingBean：判断环境中没有对应的bean(类型或名称)，才注册bean到IOC容器。
  - @ConditionalOnProperty：判断配置文件中有对应属性和值，才注册bean到IOC容器。
    
⚪ @ConditionalOnClass注解 
    
@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnClass(name="io.jsonwebtoken.Jwts")//环境中存在指定的这个类，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    
    //省略其他代码...
}
⚪pom.xml
<!--JWT令牌-->
<dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.1</version>
</dependency>
 
⚪@ConditionalOnMissingBean注解
@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnMissingBean //不存在该类型的bean，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    //SpringBoot在调用@Bean标识的headerParser()前，IOC容器中是没有HeaderParser类型的bean，所以HeaderParser对象正常创建，并注册到IOC容器中。
    //省略其他代码...
}
再次修改@ConditionalOnMissingBean注解：
@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnMissingBean(name="deptController2")//不存在指定名称的bean，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    //因为在SpringBoot环境中不存在名字叫deptController2的bean对象，所以创建HeaderParser对象并注册到IOC容器中。
    //省略其他代码...
} 
再次修改@ConditionalOnMissingBean注解：
@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnMissingBean(HeaderConfig.class)//不存在指定类型的bean，才会将bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    
    //省略其他代码...
}
@SpringBootTest
public class AutoConfigurationTests {
    @Autowired
    private ApplicationContext applicationContext;
​
    @Test
    public void testHeaderParser(){
        System.out.println(applicationContext.getBean(HeaderParser.class));
    }
    //因为HeaderConfig类中添加@Configuration注解，而@Configuration注解中包含了@Component，所以SpringBoot启动时会创建HeaderConfig类对象，并注册到IOC容器中。
​
//当IOC容器中有HeaderConfig类型的bean存在时，不会把创建HeaderParser对象注册到IOC容器中。而IOC容器中没有HeaderParser类型的对象时，通过getBean(HeaderParser.class)方法获取bean对象时，引发异常：NoSuchBeanDefinitionExceptio
    //省略其他代码...
}
​
​
@ConditionalOnProperty注解（这个注解和配置文件当中配置的属性有关系）
@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnProperty(name ="name",havingValue = "itheima")//配置文件中存在指定属性名与值，才会将bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
​
    @Bean
    public HeaderGenerator headerGenerator(){
        return new HeaderGenerator();
    }
}
修改@ConditionalOnProperty注解：  havingValue的值修改为"itheima2"
@Bean
@ConditionalOnProperty(name ="name",havingValue = "itheima2")//配置文件中存在指定属性名与值，才会将bean加入IOC容器
public HeaderParser headerParser(){
        return new HeaderParser();
    //因为application.yml配置文件中，不存在： name:  itheima2，所以HeaderParser对象在IOC容器中不存在
}

6、自定义Starter

所谓starter指的就是SpringBoot当中的起步依赖。
   在SpringBoot项目中，一般都会将这些公共组件封装为SpringBoot当中的starter，也就是我们所说的起步依赖。 
   SpringBoot官方starter命名： spring-boot-starter-xxxx
   第三组织提供的starter命名：  xxxx-spring-boot-starter
    
   Mybatis提供了配置类，并且也提供了springboot会自动读取的配置文件。当SpringBoot项目启动时，会读取到spring.factories配置文件中的配置类并加载配置类，生成相关bean对象注册到IOC容器中。
​
结果：我们可以直接在SpringBoot程序中使用Mybatis自动配置的bean对象。
    
    在自定义一个起步依赖starter的时候，按照规范需要定义两个模块：
      1. starter模块（进行依赖管理[把程序开发所需要的依赖都定义在starter起步依赖中]） 
      2. autoconfigure模块（自动配置）
    将来在项目当中进行相关功能开发时，只需要引入一个起步依赖就可以了，因为它会将autoconfigure自动配置的依赖给传递下来。
/**************************************************************************************************************/
AliOSSUtils工具类
@Component //当前类对象由Spring创建和管理
public class AliOSSUtils {
    @Autowired
    private AliOSSProperties aliOSSProperties;
​
    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile multipartFile) throws IOException {
        // 获取上传的文件的输入流
        InputStream inputStream = multipartFile.getInputStream();
​
        // 避免文件覆盖
        String originalFilename = multipartFile.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));
​
        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(aliOSSProperties.getEndpoint(),
                aliOSSProperties.getAccessKeyId(), aliOSSProperties.getAccessKeySecret());
        ossClient.putObject(aliOSSProperties.getBucketName(), fileName, inputStream);
​
        //文件访问路径
        String url =aliOSSProperties.getEndpoint().split("//")[0] + "//" + aliOSSProperties.getBucketName() + "." + aliOSSProperties.getEndpoint().split("//")[1] + "/" + fileName;
​
        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }
}    
    
    
/**************************************************************************************************************/    
 
    
- 第1步：创建自定义starter模块（进行依赖管理）
  - 把阿里云OSS所有的依赖统一管理起来
- 第2步：创建autoconfigure模块
  - 在starter中引入autoconfigure （我们使用时只需要引入starter起步依赖即可）
- 第3步：在autoconfigure中完成自动配置
  1. 定义一个自动配置类，在自动配置类中将所要配置的bean都提前配置好
  2. 定义配置文件，把自动配置类的全类名定义在配置文件中
    
    
首先我们先来创建两个Maven模块：
1). aliyun-oss-spring-boot-starter模块
2). aliyun-oss-spring-boot-autoconfigure模块
创建完starter模块后，删除多余的文件，最终保留内容如下文件
{
     aliyun-oss-spring-boot-starter.iml
     pom.xml
}
删除pom.xml文件中多余的内容后
创建完starter模块后，删除多余的文件，最终保留内容如下：
{
    src //文件
    resources//文件
    test //文件
    aliyun-oss-spring-boot-autoconfigure.iml
    pom.xml
}
删除pom.xml文件中多余的内容
    按照我们之前的分析，是需要在starter模块中来引入autoconfigure这个模块的。打开starter模块中的pom文件：

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
前两步已经完成了，接下来是最关键的就是第三步：
​
在autoconfigure模块当中来完成自动配置操作。
​
>  我们将之前案例中所使用的阿里云OSS部分的代码直接拷贝到autoconfigure模块下，然后进行改造就行了。
   拷贝过来后，还缺失一些相关的依赖，需要把相关依赖也拷贝过来：
    在类上添加的@Component注解没用了。  在SpringBoot项目中，并不会去扫描com.aliyun.oss这个包，不扫描这个包那类上的注解也就失去了作用。
   下面我们就要定义一个自动配置类了，在自动配置类当中来声明AliOSSUtils的bean对象。
AliOSSAutoConfiguration类：
@Configuration//当前类为Spring配置类
@EnableConfigurationProperties(AliOSSProperties.class)//导入AliOSSProperties类，并交给SpringIOC管理
public class AliOSSAutoConfiguration {
​
    
    //创建AliOSSUtils对象，并交给SpringIOC容器
    @Bean
    public AliOSSUtils aliOSSUtils(AliOSSProperties aliOSSProperties){
        AliOSSUtils aliOSSUtils = new AliOSSUtils();
        aliOSSUtils.setAliOSSProperties(aliOSSProperties);
        return aliOSSUtils;
    }
}
@Data 
public class AliOSSUtils {
   /****
     代码已省略
    ****/    
}
    在aliyun-oss-spring-boot-autoconfigure模块中的resources下，新建自动配置文件：
- META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 
这样就定义好了阿里云的Stater了