配置优先级

前面说到SpringBoot项目当中支持的三类配置文件：application.properties、application.yml、application.yaml。
配置一个属性，可以通过这三种方式当中的任意一种来配置，如果项目中同时存在这三种配置文件，且都配置了同一个属性，如：Tomcat端口号，到底哪一份配置文件生效呢？

配置文件优先级排名（从高到低）：

1. properties配置文件
2. yml配置文件
3. yaml配置文件

项目开发时，推荐统一使用一种格式的配置。（yml是主流）

SpringBoot为了增强程序的扩展性，除了支持配置文件的配置方式以外，还支持另外两种常见的配置方式：

1. Java系统属性配置 （格式： -Dkey=value）

-Dserver.port=9000

2. 命令行参数 （格式：–key=value）

--server.port=10010

idea中指定Java系统属性和命令行参数:
编辑启动程序的配置信息

新版idea被隐藏了需要手动添加窗口：

VM选项即存放系统属性参数，程序实参存放命令行参数。

重启服务，同时配置Tomcat端口(三种配置文件、系统属性、命令行参数)

优先级： 命令行参数 (程序实参)> 系统属性参数(VM选项) > properties参数 > yml参数 > yaml参数

思考：如果项目已经打包上线了，这个时候我们又如何来设置Java系统属性和命令行参数呢？

java -Dserver.port=9000 -jar XXXXX.jar --server.port=10010

项目打包：

运行jar程序,同时设置Java系统属性和命令行参数：

Springboot项目进行打包时，需要引入插件 spring-boot-maven-plugin (基于官网骨架创建项目，会自动添加该插件)

打包后生成俩个jar包一个是.jar 一个是.jar.original
.jar.original 是普通jar包，不包含依赖，如果是给别的项目用，就用这个
.jar 是可执行jar包，包含了pom中的所有依赖，可以直接用java -jar 命令执行，如果是部署，就用.jar

Bean管理 (掌握)

Bean的获取 ApplicationContext.getBean

默认情况下，SpringBoot项目在启动的时候会自动的创建IOC容器(也称为Spring容器)，并且在启动的过程当中会自动的将bean对象都创建好，存放在IOC容器当中。应用程序在运行时需要依赖什么bean对象，就直接进行依赖注入就可以了。
而在Spring容器中提供了一些方法，可以主动从IOC容器中获取到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)
   

• 要从IOC容器当中来获取到bean对象，需要先拿到IOC容器对象，而想获取到IOC容器，直接将IOC容器对象注入进来就可以了。

@SpringBootTest
class SpringbootWebConfig2ApplicationTests {

    @Autowired
    private ApplicationContext applicationContext; //注入IOC容器对象

    //获取bean对象
    @Test
    public void testGetBean(){
        //根据bean的名称获取
        DeptController bean1 = (DeptController) applicationContext.getBean("deptController");//这里需要强转 另外注意bean的名字默认是类名首字母小写
        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);
    }
}

运行：

输出的bean对象地址值是一样的，因为默认情况下，IOC中的bean对象是单例，实际开发当中，绝大部分的Bean是单例的，也可以将bean对象设置为非单例的，下面在bean作用域中讲解，且上述所说的 【Spring项目启动时，会把其中的bean都创建好】还会受到作用域及延迟初始化影响，这里主要针对于默认的单例非延迟加载的bean而言。

Bean的作用域 @Scope(“prototype”) @Lazy

如何设置bean对象为非单例呢？需要设置bean的作用域。在Spring中支持五种作用域，后三种在web环境才生效：

作用域	说明
singleton	容器内同名称的bean只有一个实例（单例）（默认）
prototype	每次使用该bean时会创建新的实例（非单例）
request	每个请求范围内会创建新的实例（web环境中，了解）
session	每个会话范围内会创建新的实例（web环境中，了解）
application	每个应用范围内会创建新的实例（web环境中，了解）

下面进行演示，可以借助Spring中的@Scope注解来进行配置作用域

• 控制器

//@Scope("prototype") //此时bean作用域为非单例
//默认bean的作用域为：singleton (单例)
@Lazy //延迟加载（第一次使用bean对象时，才会创建bean对象并交给ioc容器管理）
@RestController
@RequestMapping("/depts")
public class DeptController {

    @Autowired
    private DeptService deptService;

    public DeptController(){
        System.out.println("DeptController constructor ....");
    }

    //省略其他代码...
}

• 测试类

@SpringBootTest
class SpringbootWebConfig2ApplicationTests {

    @Autowired
    private ApplicationContext applicationContext; //IOC容器对象

    //bean的作用域
    @Test
    public void testScope(){
        for (int i = 0; i < 10; i++) {
            DeptController deptController = applicationContext.getBean(DeptController.class);
            System.out.println(deptController);
        }
    }
}

• 默认singleton(单例)的bean，在容器启动时被创建，可以使用@Lazy注解来延迟初始化(延迟到第一次使用时)
  修改控制器DeptController代码：@Scope(“prototype”) //bean作用域为非单例

第三方Bean @Bean @Configuration

之前我们所配置的bean，像controller、service，dao三层体系下编写的类，这些类都是我们在项目当中自己定义的类(自定义类)。要声明这些bean我们只需要在类上加上@Component以及它的这三个衍生注解（@Controller、@Service、@Repository(被@Mapper替代)），就可以来声明这个bean对象了。

但是如果是第三方的类呢？比如dom4j中的SAXReader类,按照我们之前的做法，需要在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();
    }
}

@SpringBootTest
class SpringbootWebConfig2ApplicationTests {

    @Autowired
    private SAXReader saxReader;
    ...

说明：以上在启动类中声明第三方Bean的作法，不建议使用（项目中要保证启动类的纯粹性）

解决方案2：在配置类中定义@Bean标识的方法(推荐)

如果需要定义第三方Bean时， 通常会单独定义一个配置类

package com.itheima.config

@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注解，Spring 容器在启动的时候，它会自动的调用这个方法，并将方法的返回值声明为Spring容器当中的Bean对象。

如果第三方bean需要依赖其它bean对象，直接在bean定义方法中设置形参即可，容器会根据类型自动装配。

SpringBoot底层原理 起步依赖与自动配置(无需手撸但面试高频知识点)

SpringBoot使我们能够集中精力地去关注业务功能的开发，而不用过多地关注框架本身的配置使用。SpringBoot是基于SpringFramework的(也就是Spring框架)，若基于Spring框架进行项目的开发，会比较繁琐。
繁琐主要体现在两个地方：

1. 在pom.xml中依赖配置比较繁琐，在项目开发时，需要自己去找到对应的依赖，还需要找到依赖它所配套的依赖以及对应版本，否则就会出现版本冲突问题。
2. 在使用Spring框架进行项目开发时，需要在Spring的配置文件中做大量的配置，这就造成Spring框架入门难度较大，学习成本较高。

SpringBoot框架之所以使用起来更简单更快捷，是因为SpringBoot框架底层提供了两个非常重要的功能：一个是起步依赖，一个是自动配置。
通过SpringBoot所提供的起步依赖，就可以大大的简化pom文件当中依赖的配置。
通过自动配置的功能就可以大大的简化框架在使用时bean的声明以及bean的配置。我们只需要引入程序开发时所需要的起步依赖，项目开发时所用到常见的配置都已经有了，我们直接使用就可以了。

下面先来学习SpringBoot当中起步依赖的原理。

假如我们没有使用SpringBoot，用的是Spring框架进行web程序的开发，需要引入：spring-webmvc依赖：这是Spring框架进行web程序开发所需要的依赖、servlet-api依赖：Servlet基础依赖、jackson-databind依赖：JSON处理工具包，如果要使用AOP，还需要引入aop依赖、aspect依赖，项目中所引入的这些依赖，还需要保证版本匹配。

如果我们使用了SpringBoot只需要引入一个依赖就可以了，那就是web开发的起步依赖：springboot-starter-web。

因为Maven的依赖传递，我们只需要引入一个web开发的起步依赖，web开发所需要的所有的依赖就都有了。在SpringBoot给我们提供的这些起步依赖当中，已提供了当前程序开发所需要的所有的常见依赖。

结论：起步依赖的原理就是Maven的依赖传递。

自动配置

SpringBoot的自动配置就是当Spring容器启动后，一些配置类、bean对象就自动存入到了IOC容器中，不需要我们手动去声明，从而简化了开发，省去了繁琐的配置操作。

看下自动配置的效果，运行SpringBoot启动类：

大家会看到有两个CommonConfig，在第一个CommonConfig类中定义了一个bean对象，bean对象的名字叫reader。
在第二个CommonConfig中它的bean名字叫commonConfig，为什么还会有这样一个bean对象呢？原因是在CommonConfig配置类上添加了一个注解@Configuration，而@Configuration底层就是@Component（配置类最终也是SpringIOC容器当中的一个bean对象）：

在IOC容器中除了我们自己定义的bean以外，还有很多配置类，这些配置类都是SpringBoot在启动的时候加载进来的配置类。这些配置类加载进来之后，它也会生成很多的bean对象，com.google.gson.Gson是谷歌包中提供的用来处理JSON格式数据的:

当我们想要使用这些配置类中生成的bean对象时，可以使用@Autowired就自动注入了：

@Autowired
private Gson gson;

这个bean对象怎么来的？当前项目中我们并没有声明谷歌提供的Gson这么一个bean对象。答案：SpringBoot项目在启动时通过自动配置完成了bean对象的创建。

我们知道了什么是自动配置之后，接下来我们就要来剖析自动配置的原理。

引入第三方依赖常见方案

下面通过案例，模拟在 SpringBoot项目当中，我们引入对应的依赖之后，SpringBoot是如何自动将依赖jar包当中所提供的bean以及配置类直接加载到当前项目的SpringIOC容器当中的(即自动配置的过程)。

1、在SpringBoot项目 spring-boot-web-config2 工程中，通过坐标引入itheima-utils依赖

itheima-utils：

@Component
public class TokenParser {
	public void parse(){
		System.out.println("TokenParser ... parse ...");
	}
}

2、spring-boot-web-config2 项目的测试类中，添加测试方法

@Autowired
private ApplicationContext applicationContext;

@Test
public void testTokenParse(){
    System.out.println(applicationContext.getBean(TokenParser.class));
}

3、执行测试方法

在Spring容器中没有找到com.example.TokenParse类型的bean对象

原因在我们之前讲解IOC的时候有提到过，SpringBoot项目中的@SpringBootApplication注解，具有包扫描的作用，但是它只会扫描启动类所在的当前包以及子包。当前包：com.itheima， 第三方依赖中提供的包：com.example（扫描不到）

那么如何解决以上问题？

方案1：@ComponentScan 组件扫描

修改启动类，重新执行测试方法

@SpringBootApplication
@ComponentScan({"com.itheima", "com.example"}) //指定要扫描的包
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}

缺点：当需要引入大量的第三方的依赖，会很繁琐，大面积的扫描性能也比较低。
结论：SpringBoot中并没有采用以上这种方案

方案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导入配置类

itheima-utils自己准备的配置类：

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

3. 使用@Import导入ImportSelector接口实现类

itheima-utils自己准备的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);
    }
}

上面这三种使用@Import注解的方式都可以导入第三方依赖中所提供的bean或者是配置类。
缺点：当要引入一个第三方依赖时，还要知道第三方依赖中有哪些配置类和哪些Bean对象。

结论：SpringBoot也没有使用上述三种方式，而是使用第三方依赖提供的@EnableXxxxx注解，因为依赖中到底有哪些bean和配置类第三方依赖自身最清楚，所以让第三方依赖它自己来指定要导入哪些bean对象和配置类。

方案3：使用第三方依赖提供的@EnableXxxxx注解(底层采用这个)

怎么让第三方依赖自己指定bean对象和配置类？比较常见的方案就是第三方依赖给我们提供一个注解，这个注解一般都以@EnableXxxx开头的注解，注解中封装的就是@Import注解。

itheima-utils自己准备的@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);
    }
}

@SpringBootApplication源码跟踪分析原理

下面通过源码跟踪的形式来剖析下SpringBoot底层到底是如何完成自动配置的。

在跟踪框架源码的时候，一定要抓住关键点，找到核心流程。一定不要从头到尾一行代码去看，一个方法的去研究，有精力再去研究其中的细节。

要搞清楚SpringBoot的自动配置原理，要从SpringBoot启动类上使用的核心注解@SpringBootApplication开始分析,按住ctrl进入其源码：

1.先来看第一个注解：@SpringBootConfiguration

@SpringBootConfiguration注解上使用了@Configuration，表明SpringBoot启动类就是一个配置类。
@Indexed注解，是用来加速应用启动的（不用关心）

2.再看@ComponentScan注解

@ComponentScan注解是用来进行组件扫描的，扫描启动类所在的包及其子包下所有被@Component及其衍生注解声明的类。
SpringBoot启动类，之所以具备扫描包功能，就是因为包含了@ComponentScan注解。

3.最后看@EnableAutoConfiguration注解（自动配置核心注解）：

使用@Import注解，导入了实现ImportSelector接口的实现类。AutoConfigurationImportSelector类是ImportSelector接口的实现类。

AutoConfigurationImportSelector类中重写了ImportSelector接口的selectImports()方法：

selectImports()方法底层调用getAutoConfigurationEntry()方法，获取可自动配置的配置类信息集合

getAutoConfigurationEntry()方法通过调用getCandidateConfigurations(annotationMetadata, attributes)方法获取在配置文件中配置的所有自动配置类的集合

getCandidateConfigurations方法的功能：
获取所有基于METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件、META-INF/spring.factories文件中配置类的集合


METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件和META-INF/spring.factories文件这两个文件在哪里呢？
通常在引入的起步依赖中，都有包含以上两个文件:

在前面在给大家演示自动配置的时候，我们直接在测试类当中注入了一个叫gson的bean对象，我们没有配置bean对象，但是我们是可以直接注入使用的。原因就是因为在自动配置类当中做了自动配置。到底是在哪个自动配置类当中做的自动配置呢？我们通过搜索来查询一下。

在METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports配置文件中指定了第三方依赖Gson的配置类：GsonAutoConfiguration

在GsonAutoConfiguration类上，添加了注解@AutoConfiguration，通过查看源码，可以明确：GsonAutoConfiguration类是一个配置。

综上，自动配置的原理就是在配置类中定义一个@Bean标识的方法，而Spring会自动调用配置类中使用@Bean标识的方法，并把方法的返回值注册到IOC容器中。

自动配置源码小结

自动配置原理源码入口就是@SpringBootApplication注解，在这个注解中封装了3个注解，分别是：

• @SpringBootConfiguration
  • 声明当前类是一个配置类
• @ComponentScan
  • 进行组件扫描（SpringBoot中默认扫描的是启动类所在的当前包及其子包）
• @EnableAutoConfiguration (就是我们上面学习的@EnableXxxxx)
  • 封装了@Import注解（Import注解中指定了一个ImportSelector接口的实现类）
    • 在实现类重写的selectImports()方法，读取当前项目下所有依赖jar包中META-INF/spring.factories、META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports两个文件里面定义的配置类（配置类中定义了@Bean注解标识的方法）。

当SpringBoot程序启动时，就会加载配置文件当中所定义的配置类，并将这些配置类信息(类的全限定名)封装到String类型的数组中，最终通过@Import注解将这些配置类全部加载到Spring的IOC容器中，交给IOC容器管理。

文件中定义的配置类非常多，而且每个配置类中又可以定义很多的bean，那这些bean都会注册到Spring的IOC容器中吗？
并不是。 在声明bean对象时，上面还经常有加一个以@Conditional开头的注解，这种注解的作用就是按照条件进行装配，只有满足条件之后，才会将bean注册到Spring的IOC容器中。

@Conditional

• 作用：按照一定的条件进行判断，在满足给定条件后才会注册对应的bean对象到Spring的IOC容
  器中。
• 位置：方法、类
• @Conditional本身是一个父注解，派生出大量的子注解：
  • @ConditionalOnClass：判断环境中有对应字节码文件，才注册bean到IOC容 器。
  • @ConditionalOnMissingBean：判断环境中没有对应的bean(类型或名称)，才注册bean到IOC容器。
  • @ConditionalOnProperty：判断配置文件中有对应属性和值，才注册bean到IOC容器。

下面通过代码来演示下Conditional注解的使用。

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

• 测试类

@SpringBootTest
public class AutoConfigurationTests {
    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void testHeaderParser(){
        System.out.println(applicationContext.getBean(HeaderParser.class));
    }
    //省略其他代码...
}

无报错通过testHeaderParser()测试方法，因为io.jsonwebtoken.Jwts字节码文件在启动SpringBoot程序时已存在，所以创建HeaderParser对象并注册到IOC容器中。

• @ConditionalOnMissingBean注解

@Configuration
public class HeaderConfig {

    @Bean
    @ConditionalOnMissingBean //不存在该类型的bean，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    //省略其他代码...
}

通过了testHeaderParser()测试方法： 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();
    }
    //省略其他代码...
}

执行通过了testHeaderParser()测试方法：因为在SpringBoot环境中不存在名字叫deptController2的bean对象，所以创建HeaderParser对象并注册到IOC容器中。

再次修改@ConditionalOnMissingBean注解：

@Configuration
public class HeaderConfig {

    @Bean
    @ConditionalOnMissingBean(HeaderConfig.class)//不存在指定类型的bean，才会将bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    //省略其他代码...
}

执行不通过testHeaderParser()测试方法： 因为HeaderConfig类中添加@Configuration注解，而@Configuration注解中包含了@Component，所以SpringBoot启动时会创建HeaderConfig类对象，并注册到IOC容器中。通过getBean(HeaderParser.class)方法获取bean对象时，引发异常：NoSuchBeanDefinitionException

• @ConditionalOnProperty注解（这个注解和配置文件当中配置的属性有关系）

先在application.yml配置文件中添加如下的键值对：

name: itheima

在声明bean的时候就可以指定一个条件@ConditionalOnProperty

@Configuration
public class HeaderConfig {
    @Bean
    @ConditionalOnProperty(name ="name",havingValue = "itheima")//配置文件中存在指定属性名与值，才会将bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }

执行通过testHeaderParser()测试方法，修改@ConditionalOnProperty注解： havingValue的值修改为"itheima2"，再次执行不通过。

自动配置案例——阿里云starter

所谓starter指的就是SpringBoot当中的起步依赖。在SpringBoot当中已经给我们提供了很多的起步依赖了，在实际的项目开发当中，可能会用到很多第三方的技术，并不是所有的第三方的技术官方都给我们提供了与SpringBoot整合的starter起步依赖，但是这些技术又非常的通用，在很多项目组当中都在使用。

前面案例中使用了阿里云OSS对象存储服务，现在阿里云的官方是没有给我们提供对应的起步依赖的，这个时候使用起来就会比较繁琐，所以这个时候我们就可以自定义一些公共组件，在其中提前把需要配置的bean都提前配置好。将来在项目当中，想使用这个技术，直接将组件对应的坐标直接引入进来，就已经自动配置好了，可以直接使用了。

在SpringBoot项目中，一般都会将这些公共组件封装为SpringBoot当中的starter，也就是我们所说的起步依赖，starter在引用对应的autoconfigure包，在这个包中完成自动配置操作，那么将来在项目中进行项目对应功能开发只需要引入对应的starter就行了，因为它会将autoconfigure自动配置的依赖传递下来。

SpringBoot官方starter命名： spring-boot-starter-xxxx
第三方组织提供的starter命名： xxxx-spring-boot-starter

在自定义一个起步依赖starter的时候，按照规范需要定义两个模块：

1. starter模块（进行依赖管理[把程序开发所需要的依赖都定义在starter起步依赖中]）
2. autoconfigure模块（自动配置）

案例需求：自定义aliyun-oss-spring-boot-starter，完成阿里云OSS操作工具类AliyunOSSUtils的自动配置。
目标：引入起步依赖引入之后，要想使用阿里云OSS，注入AliyunOSSUtils直接使用即可。

之前阿里云OSS的使用：

• 配置文件

#配置阿里云OSS参数
aliyun:
  oss:
    endpoint: https://oss-cn-shanghai.aliyuncs.com
    accessKeyId: #密钥省略
    accessKeySecret: #省略
    bucketName: web-framework01
#这个是老版本的用法，最新版本accessKeyId和accessKeySecret已经无需以明文的方式放在代码中，而是存放在环境变量中，这里为了演示案例继续用老版本的代码

• AliOSSProperties类

@Data
@Component
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOSSProperties {
    //区域
    private String endpoint;
    //身份ID
    private String accessKeyId ;
    //身份密钥
    private String accessKeySecret ;
    //存储空间
    private String bucketName;
}

• 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模块

创建完starter模块后，删除多余的文件，最终保留内容如下：

删除pom.xml文件中多余的内容后：

<?xml version="1.0" encoding="UTF-8"?>
<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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.5</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<groupId>com.aliyun.oss</groupId>
	<artifactId>aliyun-oss-spring-boot-starter</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<java.version>11</java.version>
	</properties>
	
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
	</dependencies>

</project>

2). aliyun-oss-spring-boot-autoconfigure模块

创建完starter模块后，删除多余的文件，最终保留内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.5</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	
	<groupId>com.aliyun.oss</groupId>
	<artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<java.version>11</java.version>
	</properties>

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

</project>

按照我们之前的分析，是需要在starter模块中来引入autoconfigure这个模块的。打开starter模块中的pom文件：

		<!--引入autoconfigure模块-->
		<dependency>
			<groupId>com.aliyun.oss</groupId>
			<artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>

前两步已经完成了，接下来是最关键的就是第三步，在autoconfigure模块当中来完成自动配置操作。我们将之前案例中所使用的阿里云OSS部分的代码直接拷贝到autoconfigure模块下，然后进行改造就行了。

拷贝过来后，还缺失一些相关的依赖，需要把相关依赖也拷贝过来：

		<!--引入web起步依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!--Lombok-->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>

		<!--阿里云OSS-->
		<dependency>
			<groupId>com.aliyun.oss</groupId>
			<artifactId>aliyun-sdk-oss</artifactId>
			<version>3.15.1</version>
		</dependency>

		<dependency>
			<groupId>javax.xml.bind</groupId>
			<artifactId>jaxb-api</artifactId>
			<version>2.3.1</version>
		</dependency>
		<dependency>
			<groupId>javax.activation</groupId>
			<artifactId>activation</artifactId>
			<version>1.1.1</version>
		</dependency>
		<!-- no more than 2.3.3-->
		<dependency>
			<groupId>org.glassfish.jaxb</groupId>
			<artifactId>jaxb-runtime</artifactId>
			<version>2.3.3</version>
		</dependency>

因为在SpringBoot项目中，并不会去扫描com.aliyun.oss这个包，不扫描这个包那
类上的注解也就失去了作用，所以删除两个类中的@Component注解、@Autowired注解。

下面我们就要定义一个自动配置类了，在自动配置类当中来声明AliOSSUtils的bean对象。

AliOSSAutoConfiguration类：

@Configuration//当前类为Spring配置类
@EnableConfigurationProperties(AliOSSProperties.class)//直接导入AliOSSProperties类，并交给SpringIOC管理,因为AliOSSProperties现在没有@Component了,但是我们这里又需要用到AliOSSProperties对象
//这个注解只能用在配置类上或者声明Bean的方法上 底层封装的也还是@import
public class AliOSSAutoConfiguration {
    //创建AliOSSUtils对象，并交给SpringIOC容器
    @Bean
    public AliOSSUtils aliOSSUtils(AliOSSProperties aliOSSProperties){
        AliOSSUtils aliOSSUtils = new AliOSSUtils();
        aliOSSUtils.setAliOSSProperties(aliOSSProperties);
        return aliOSSUtils;
    }
}

AliOSSProperties类：

/*阿里云OSS相关配置*/
@Data
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOSSProperties {
    //区域
    private String endpoint;
    //身份ID
    private String accessKeyId ;
    //身份密钥
    private String accessKeySecret ;
    //存储空间
    private String bucketName;
}

AliOSSUtils类：

@Data 
public class AliOSSUtils {
    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的路径返回
    }
}

最后在aliyun-oss-spring-boot-autoconfigure模块中的resources下，新建自动配置文件：

• META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

  com.aliyun.oss.AliOSSAutoConfiguration
  

![在这里插入图片描述](https://img-blog.csdnimg.cn/80b3827b49c245788a0ff62f87ad8e5b.png)


至此阿里云起步依赖配置完毕，可以新建一个test工程，在工程里引用阿里云starter依赖，通过依赖传递，会把autoconfigure依赖也引入了。

~~~xml
   <!--引入阿里云OSS起步依赖-->
   <dependency>
       <groupId>com.aliyun.oss</groupId>
       <artifactId>aliyun-oss-spring-boot-starter</artifactId>
       <version>0.0.1-SNAPSHOT</version>
   </dependency>

在test工程中的application.yml文件中，配置阿里云OSS配置参数信息（从以前的工程中拷贝即可）

   #配置阿里云OSS参数
   aliyun:
     oss:
       endpoint: https://oss-cn-shanghai.aliyuncs.com
       accessKeyId: #密钥省略
       accessKeySecret: #省略
       bucketName: web-framework01

在test工程中的UploadController类编写测试代码

   @RestController
   public class UploadController {
   
       @Autowired
       private AliOSSUtils aliOSSUtils;
   
       @PostMapping("/upload")
       public String upload(MultipartFile image) throws Exception {
           //上传文件到阿里云 OSS
           String url = aliOSSUtils.upload(image);
           return url;
       }
   
   }

随着SpringBoot项目启动，自动配置会把AliOSSUtils的bean对象装配到IOC容器中

postman测试上传图片：

到此基于SpringBoot进行web后端开发的相关知识我们已经学习完毕了。

Web后端开发总结(概念八股)

回顾一下关于web后端开发，我们都学习了哪些内容，以及每一块知识，具体是属于哪个框架的。

web后端开发现在基本上都是基于标准的三层架构进行开发的，Controller控制器
层负责接收请求响应数据，Service业务层负责具体的业务逻辑处理，而Dao数据访问层也叫持久层，就是用来处理数据访问操作的，来完成数据库当中数据的增删改查操作。

如果我们在执行具体的业务处理之前，需要去做一些通用的业务处理，比如：我们要进行统一的登录校验，我们要进行统一的字符编码等这些操作时，我们就可以借助于Javaweb当中三大组件之一的过滤器Filter或者是Spring当中提供的拦截器Interceptor来实现。

而为了实现三层架构层与层之间的解耦，我们学习了Spring框架当中的第一大核心：IOC控制反转(将对象创建的控制权由应用程序自身交给外部IOC容器)与DI依赖注入(容器为程序提供运行时所需要的资源)。

除了IOC与DI我们还讲到了AOP面向切面编程，还有Spring中的事务管理、全局异常处理器，以及传递会话技术Cookie、Session以及新的会话跟踪解决方案JWT令牌，阿里云OSS对象存储服务，以及通过Mybatis持久层架构操作数据库等技术。

Filter过滤器、Cookie、 Session这些都是传统的JavaWeb提供的技术。
JWT令牌、阿里云OSS对象存储服务，是现在企业项目中常见的一些解决方案。
IOC控制反转、DI依赖注入、AOP面向切面编程、事务管理、全局异常处理、拦截器等，这些技术都是 Spring Framework框架当中提供的核心功能。
Mybatis就是一个持久层的框架，是用来操作数据库的。

在Spring框架的生态中，对web程序开发提供了很好的支持，如：全局异常处理器、拦截器这些都是Spring框架中web开发模块所提供的功能，而Spring框架的web开发模块，我们也称为：SpringMVC

SpringMVC不是一个单独的框架，它是Spring框架的一部分，是Spring框架中的web开发模块，是用来简化原始的Servlet程序开发的。

外界俗称的SSM，就是由：SpringMVC、Spring Framework、Mybatis三块组成。基于传统的SSM框架进行整合开发项目会比较繁琐，而且效率也比较低，所以在现在的企业项目开发当中，基本上都是直接基于SpringBoot整合SSM进行项目开发的。