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获取beanObject 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 {
​@Autowiredprivate ApplicationContext applicationContext; //获取IOC容器对象
​//获取bean对象@Testpublic 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容器beanpublic 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 {@Beanpublic HeaderParser headerParser(){return new HeaderParser();}
​@Beanpublic 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 {@Autowiredprivate ApplicationContext applicationContext;
​@Testpublic void testHeaderParser(){System.out.println(applicationContext.getBean(HeaderParser.class));}  @Testpublic 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 {@Autowiredprivate ApplicationContext applicationContext;
​@Testpublic 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();}
​@Beanpublic 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-starterMybatis提供了配置类，并且也提供了springboot会自动读取的配置文件。当SpringBoot项目启动时，会读取到spring.factories配置文件中的配置类并加载配置类，生成相关bean对象注册到IOC容器中。
​
结果：我们可以直接在SpringBoot程序中使用Mybatis自动配置的bean对象。在自定义一个起步依赖starter的时候，按照规范需要定义两个模块：1. starter模块（进行依赖管理[把程序开发所需要的依赖都定义在starter起步依赖中]） 2. autoconfigure模块（自动配置）将来在项目当中进行相关功能开发时，只需要引入一个起步依赖就可以了，因为它会将autoconfigure自动配置的依赖给传递下来。
/**************************************************************************************************************/
AliOSSUtils工具类
@Component //当前类对象由Spring创建和管理
public class AliOSSUtils {@Autowiredprivate 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("."));
​//上传文件到 OSSOSS 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;
​// 关闭ossClientossClient.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.imlpom.xml
}
删除pom.xml文件中多余的内容后
创建完starter模块后，删除多余的文件，最终保留内容如下：
{src //文件resources//文件test //文件aliyun-oss-spring-boot-autoconfigure.imlpom.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容器@Beanpublic 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了