Spring/Spring Boot重点知识整理

超、凢脫俗 2023-07-06 11:44 10阅读 0赞

##### Why Spring #####

*  **非侵入式**：支持基于POJO的编程模式，不强制性的要求实现Spring框架中的接口或继承Spring框架中的类，这些功能赋予了将其与其他技术结合使用的灵活性。例如，我们可以使用@Inject不是基于Spring的注解的注解来注入依赖项。
 *  **IOC容器**：IoC容器帮助应用程序管理对象以及对象之间的依赖关系，对象之间的依赖关系如果发生了改变只需要修改配置文件而不是修改代码，因为代码的修改可能意味着项目的重新构建和完整的回归测试。有了IoC容器，程序员再也不需要自己编写工厂、单例，这一点特别符合Spring的精神“不要重复的发明轮子”。
 *  **AOP（面向切面编程）**：将所有的横切关注功能封装到切面（aspect）中，通过配置的方式将横切关注功能动态添加到目标代码上，进一步实现了业务逻辑和系统服务之间的分离。另一方面，有了AOP程序员可以省去很多自己写代理类的工作。
 *  **事务管理**：Spring以宽广的胸怀接纳多种持久层技术，并且为其提供了声明式的事务管理，在不需要任何一行代码的情况下就能够完成事务管理。
 *  **MVC**：Spring的MVC框架是非常优秀的，为Web表示层提供了更好的解决方案。
 *  **异常处理**：Spring Framework提供了多个选项，以更好，更灵活的方式处理异常。

##### Spring IOC #####

IOC即Inversion of control，直译过来就是控制反转，它的意思是将对象，以及对象之间的引用关系，交给容器管理（The IOC container）。

在IOC出现以前，组件之间的协调关系是由程序内部代码来控制的，或者说，以前我们使用New object()这样子的语法实现两组件之间的依赖关系的。这种方式就造成了组件之间的互相耦合。IOC(控制反转)就是来解决这个问题的，它将实现组件间的关系从程序内部提到外部容器来管理（The IOC container）。也就是说，由容器在运行期将组件间的某种依赖关系动态的注入组件中。

**Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。**

IOC是基于工厂模式加反射机制实现的。

##### Spring Bean作用域 #####

<table> 
 <thead> 
  <tr> 
   <th>作用域</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>singleton</td> 
   <td>单例模式，在整个Spring IoC容器中，singleton作用域的Bean将只生成一个实例，为Spring的默认值</td> 
  </tr> 
  <tr> 
   <td>prototype</td> 
   <td>每次注入或者通过Spring应用上下文获取的时候，都会创建一个新的Bean。</td> 
  </tr> 
  <tr> 
   <td>request</td> 
   <td>对于一次HTTP请求，request作用域的Bean将只生成一个实例，这意味着，在同一次HTTP请求内，程序每次请求该Bean，得到的总是同一个实例。</td> 
  </tr> 
  <tr> 
   <td>session</td> 
   <td>该作用域将 bean 的定义限制为 HTTP 会话。在web应用中为每一个会话创建一个Bean实例。</td> 
  </tr> 
 </tbody> 
</table>

通常可以这样子设置Bean的作用域

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

或者这样子

##### Bean的生命周期 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70]

1.  Spring对Bean进行实例化
2.  Spring将值和Bean的引用注入到Bean对应的属性中
3.  如果Bean实现了BeanNameAware接口，Spring将Bean的ID传给setBean-Name()方法
4.  如果Bean实现了BeanFactoryAware接口，Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入
5.  如果Bean实现了ApplicationContextAware接口，Spring将调用setApplicationContext()方法，将Bean所在的应用上下文的引用传入进来
6.  如果Bean实现了BeanPostProcessor接口，Spring将调用它们的post-ProcessBeforeInitialization()方法
7.  如果Bean实现了InitializingBean接口，Spring将调用它们的after-PropertiesSet()方法。类似的，如果Bean使用了init-method生命了初始化方法，该方法也会被调用。
8.  如果Bean实现了BeanPostProcessor接口，Spring将调用它们的post-ProcessAfterInitialization()方法
9.  至此，Bean已经准备就绪，可以被应用程序使用了
10. 如果Bean实现了DisposableBean接口，Spring将调用它的destory()方法。同样，如果Bean使用了destory-method声明了销毁方法，该方法也会被调用。

##### Bean注入的三种方式 #####

*  构造方法注入
 *  setter注入
 *  `@Autowired`注解

##### Spring如何标记首选的Bean #####

@Component
    	@Primary
    	public class Student {
    		// todo...
    	}

##### 限定自动装配的Bean #####

@Autowired
        @Qualifier("student")
        public void setName(String policyName) {
            this.policyName = policyName;
        }

##### Spring 自动装配Bean的方法 #####

*  no：默认值，表示没有自动装配，应使用显式 bean 引用进行装配。
 *  byName：它根据 bean 的名称注入对象依赖项。
 *  byType：它根据类型注入对象依赖项。
 *  构造函数：通过构造函数来注入依赖项，需要设置大量的参数。
 *  autodetect：容器首先通过构造函数使用 autowire 装配，如果不能，则通过 byType 自动装配。

##### BeanFactory和ApplicationContext的区别 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 1]

*  BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载、实例化，控制bean的生命周期，维护bean之间的依赖关系。ApplicationContext接口作为BeanFactory的派生，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能：
    
     *  继承MessageSource，因此支持国际化。
     *  统一的资源文件访问方式。
     *  提供在监听器中注册bean的事件。
     *  同时加载多个配置文件。
     *  载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层。
 *  BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。这样，我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常；而ApplicationContext则在初始化自身是检验，这样有利于检查所依赖属性是否注入；所以通常情况下我们选择使用 ApplicationContext。
 *  BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。
 *  BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。

##### @Autowire如何实现注入Bean #####

*  这是@Autowire注解的定义

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Autowired {
    
    	/**
    	 * Declares whether the annotated dependency is required.
    	 * <p>Defaults to {@code true}.
    	 */
    	boolean required() default true;
    
    }

*  Java中注解的实现方式是通过反射来实现，反射的大概步骤如下：
    
     *  利用反射机制获取一个类的Class对象
     *  通过这个class对象可以去获取他的每一个方法method，或字段Field等等
     *  Method，Field等类提供了类似于getAnnotation的方法来获取这个一个字段的所有注解
     *  拿到注解之后，我们可以判断这个注解是否是我们要实现的注解，如果是则实现注解逻辑
 *  所有的实现逻辑都在`org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor`，核心代码如下：

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
    		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
    		// 需要处理的目标类
    		Class<?> targetClass = clazz;
    
    		do {
    			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
    			// 通过反射获取所有字段，通过findAutowiredAnnotation查找每个字段的注解，如果用autowired修饰则返回autowired相关属性
    			ReflectionUtils.doWithLocalFields(targetClass, field -> {
    				AnnotationAttributes ann = findAutowiredAnnotation(field);
    				if (ann != null) {
    					// 是否用在了static字段上
    					if (Modifier.isStatic(field.getModifiers())) {
    						if (logger.isWarnEnabled()) {
    							logger.warn("Autowired annotation is not supported on static fields: " + field);
    						}
    						return;
    					}
    					// required属性是否赋值，默认true
    					boolean required = determineRequiredStatus(ann);
    					currElements.add(new AutowiredFieldElement(field, required));
    				}
    			});
    			// 同理通过反射获取所有方法并处理被autowired修饰的方法
    			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
    				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
    				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
    					return;
    				}
    				AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
    				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
    					// 是否用在static方法上
    					if (Modifier.isStatic(method.getModifiers())) {
    						if (logger.isWarnEnabled()) {
    							logger.warn("Autowired annotation is not supported on static methods: " + method);
    						}
    						return;
    					}
    					if (method.getParameterCount() == 0) {
    						if (logger.isWarnEnabled()) {
    							logger.warn("Autowired annotation should only be used on methods with parameters: " +
    									method);
    						}
    					}
    					boolean required = determineRequiredStatus(ann);
    					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
    					currElements.add(new AutowiredMethodElement(method, required, pd));
    				}
    			});
    			// 用@Autowired修饰的注解可能不止一个，因此都加在currElements这个容器里面，一起处理	
    			elements.addAll(0, currElements);
    			targetClass = targetClass.getSuperclass();
    		}
    		while (targetClass != null && targetClass != Object.class);
    		// 返回所有包含autowire注解修饰的一个InjectionMetadata集合
    		return new InjectionMetadata(clazz, elements);
    	}

以上的代码就获取到了所有被autowire注解修饰的目标类和所有elements集合。  
有了目标类，与所有需要注入的元素集合之后，我们就可以实现autowired的依赖注入逻辑了，实现的方法如下:

@Override
    	public PropertyValues postProcessPropertyValues(
    			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
    		// 这里是之前找到的目标类和所有elements集合组成的metadata
    		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    		try {
    			// 然后调用metadata的inject方法
    			metadata.inject(bean, beanName, pvs);
    		}
    		catch (BeanCreationException ex) {
    			throw ex;
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    		}
    		return pvs;
    	}

inject也使用了反射技术并且依然是分成字段和方法去处理的

protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
    				throws Throwable {
    			// 如果autowired修饰的是属性，则赋值
    			if (this.isField) {
    				Field field = (Field) this.member;
    				ReflectionUtils.makeAccessible(field);
    				field.set(target, getResourceToInject(target, requestingBeanName));
    			}
    			else {
    				if (checkPropertySkipping(pvs)) {
    					return;
    				}
    				// 否则autowired修饰在方法上，则调用method.invoke
    				try {
    					Method method = (Method) this.member;
    					ReflectionUtils.makeAccessible(method);
    					method.invoke(target, getResourceToInject(target, requestingBeanName));
    				}
    				catch (InvocationTargetException ex) {
    					throw ex.getTargetException();
    				}
    			}
    		}

以上就是@Autowired注解实现的所有逻辑。

##### Spring中的循环依赖问题 #####

*  构造器的循环依赖
    
        <bean id="testA" class="com.bean.TestA">
            <constructor-arg index="0" ref="testB" />
        </bean>
        <bean id="testB" class="com.bean.TestB">
            <constructor-arg index="0" ref="testC" />
        </bean>
        <bean id="testC" class="com.bean.TestC">
            <constructor-arg index="0" ref="testA" />
        </bean>
    
     *  解决方法：spring无法解决这种问题，只能抛出BeanCurrentlyInCreationException异常来终止该依赖。
     *  具体的处理步骤如下：
    
    1.  Spring将每个正在创建的bean的标识符放在一个池子里
    2.  如果bean在创建的时候发现自己已经存在于这个池子里
    3.  则抛出异常，中断循环依赖。
 *  属性的循环依赖， setter循环依赖
    
        <bean id="testA" class="com.bean.TestA">
            <property name="testB" ref="testB" />
        </bean>
        <bean id="testB" class="com.bean.TestB">
            <property name="testC" ref="testC" />
        </bean>
        <bean id="testC" class="com.bean.TestC">
            <property name="testA" ref="testA" />
        </bean>
    
     *  解决方法：
    
    1.  spring将已经完成了构造注入但是未完成setter注入的bean暴露出来
    2.  当进行setter注入时，发现这个需被注入的bean已经被暴露出来（存在该bean的引用），直接注入即可，而不需要再次加载所需的bean(无需再经历从头开始加载一个bean的过程，也就不会报错了)。

##### Spring AOP #####

*  Spring AOP是Spring框架中的重中之重，是基于JDK动态代理和CGLib动态代理实现的，至于动态代理的知识点可以参考我的这篇[文章][Link 1]，Spring AOP默认采用JDK动态代理实现机制。
 *  AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
 *  通俗来讲，在我们的应用中，诸如常见的日志、安全、异常处理和事物等逻辑都很重要，在不适用AOP的过去，我们需要将共同部分的这段代码写在一个独立的类独立的方法里，然后再去调用。但是有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。
 *  AOP的基本概念
    
     *  通知（Advice）  
        通知定义了切面是什么以及什么时候使用。Spring切面可以应用五种类型的通知：
        
         *  前置通知（Before）： 在目标方法被调用之前通知功能。
         *  后置通知（After）：在目标方法被调用之后通知功能。
         *  返回通知（After-returning）：在目标方法执行成功之后调用通知。
         *  异常通知（After-throwing）：在目标方法抛出异常之后调用通知。
         *  环绕通知（Around）：通知包含了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。
     *  连接点（Join Point）：在应用中执行过程中能够插入切面的一个点。
     *  切点（Pointcut）：切点定义了匹配通知在何处织入。
     *  切面（Aspect）：切面是通知和切点的集合。通知和切点共同定义了切面的全部内容–它是什么、在何时在何处完成功能
 *  AOP切点表达式

<table> 
 <thead> 
  <tr> 
   <th>AspectJ指示器</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>arg()</td> 
   <td>限制连接点匹配参数由指定类型的执行方法</td> 
  </tr> 
  <tr> 
   <td>@arg()</td> 
   <td>限制连接点匹配参数由指定注解标注的执行方法</td> 
  </tr> 
  <tr> 
   <td>execution()</td> 
   <td>用于匹配是连接点的执行方法</td> 
  </tr> 
  <tr> 
   <td>this()</td> 
   <td>限制连接点匹配AOP代理的bean引用为指定类型的类</td> 
  </tr> 
  <tr> 
   <td>target</td> 
   <td>限制连接点匹配目标对象为指定类型的类</td> 
  </tr> 
  <tr> 
   <td>@target()</td> 
   <td>限制连接点匹配特定的执行对象</td> 
  </tr> 
  <tr> 
   <td>within()</td> 
   <td>限制连接点匹配指定的类型</td> 
  </tr> 
  <tr> 
   <td>@within()</td> 
   <td>限制连接点匹配指定注解所标注的类型</td> 
  </tr> 
  <tr> 
   <td>@annotation</td> 
   <td>限制连接点匹配有指定注解的连接点</td> 
  </tr> 
 </tbody> 
</table>

*  AOP使用场景
    
     *  Authentication 权限
     *  Caching 缓存
     *  Context passing 内容传递
     *  Error handling 错误处理
     *  Lazy loading　懒加载
     *  Debugging　　调试
     *  logging, tracing, profiling and monitoring　记录跟踪　优化　校准
     *  Performance optimization　性能优化
     *  Persistence　　持久化
     *  Resource pooling　资源池
     *  Synchronization　同步
     *  Transactions 事务

##### Spring事物 #####

事务主要有四个特性，我们根据它的英文大写字母简写成：ACID

*  原子性（Atomicity）

事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。所以你可以把一个事务看成一个原子操作。

*  一致性（Consistency）

一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。比如在银行转账的例子中，无论转账成功与否，都需要保证银行的总存款是不变的，这才符合业务的“一致”状态。

*  隔离性（Isolation）

可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。这里涉及到事务的几种隔离级别，将在下文详细介绍。比如多个人都像B转账，他们之间的事务互相不能影响。

*  持久性（Durability）

一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器（如数据库）中。

*  事物的隔离级别
    
     *  Isolation.DEFAULT：用底层数据库的设置隔离级别，数据库设置的是什么我就用什么；
     *  Isolation.READ\_UNCOMMITTED：未提交读，最低隔离级别、事务未提交前，就可被其他事务读取（会出现幻读、脏读、不可重复读）；
     *  Isolation.READ\_COMMITTED：提交读，一个事务提交后才能被其他事务读取到（会造成幻读、不可重复读），SQL server 的默认级别；
     *  Isolation.REPEATABLE\_READ：可重复读，保证多次读取同一个数据时，其值都和事务开始时候的内容是一致，禁止读取到别的事务未提交的数据（会造成幻读），MySQL 的默认级别；
     *  Isolation.SERIALIZABLE：序列化，代价最高最可靠的隔离级别，该隔离级别能防止脏读、不可重复读、幻读。
     *  脏读 ：表示一个事务能够读取另一个事务中还未提交的数据。比如，某个事务尝试插入记录 A，此时该事务还未提交，然后另一个事务尝试读取到了记录 A。
     *  不可重复读 ：是指在一个事务内，多次读同一数据。
     *  幻读 ：指同一个事务内多次查询返回的结果集不一样。比如同一个事务 A 第一次查询时候有 n 条记录，但是第二次同等条件下查询却有 n+1 条记录，这就好像产生了幻觉。发生幻读的原因也是另外一个事务新增或者删除或者修改了第一个事务结果集里面的数据，同一个记录的数据内容被修改了，所有数据行的记录就变多或者变少了。
 *  更多详细内容请看我的和篇[文章][Link 2]

##### Spring事务的传播属性 #####

在Spring的事务机制中对数据库存在7种传播行为，通过枚举类Propagation定义。

public enum Propagation {
        /**
         * 需要事务，默认传播性行为。
         * 如果当前存在事务，就沿用当前事务，否则新建一个事务运行子方法
         */
        REQUIRED(0),
        /**
         * 支持事务，如果当前存在事务，就沿用当前事务，
         * 如果不存在，则继续采用无事务的方式运行子方法
         */
        SUPPORTS(1),
        /**
         * 必须使用事务，如果当前没有事务，抛出异常
         * 如果存在当前事务,就沿用当前事务
         */
        MANDATORY(2),
        /**
         * 无论当前事务是否存在，都会创建新事务允许方法
         * 这样新事务就可以拥有新的锁和隔离级别等特性，与当前事务相互独立
         */
        REQUIRES_NEW(3),
        /**
         * 不支持事务，当前存在事务时，将挂起事务，运行方法
         */
        NOT_SUPPORTED(4),
        /**
         * 不支持事务，如果当前方法存在事务，将抛出异常，否则继续使用无事务机制运行
         */
        NEVER(5),
        /**
         * 在当前方法调用子方法时，如果子方法发生异常
         * 只回滚子方法执行过的SQL，而不回滚当前方法的事务
         */
        NESTED(6);
        ......
    }

日常开发中基本只会使用到REQUIRED(0),REQUIRES\_NEW(3),NESTED(6)三种。

##### Spring MVC有哪些组件 #####

*  前置控制器 DispatcherServlet。
 *  映射控制器 HandlerMapping。
 *  处理器 Controller。
 *  模型和视图 ModelAndView。
 *  视图解析器 ViewResolver。

##### Spring MVC的运行流程 #####

*  先将请求发送给 DispatcherServlet。
 *  DispatcherServlet 查询一个或多个 HandlerMapping，找到处理请求的 Controller。
 *  DispatcherServlet 再把请求提交到对应的 Controller。
 *  Controller 进行业务逻辑处理后，会返回一个ModelAndView。
 *  Dispathcher 查询一个或多个 ViewResolver 视图解析器，找到 ModelAndView 对象指定的视图对象。
 *  视图对象负责渲染返回给客户端。

##### Why Spring Boot #####

*  自动配置
 *  上手简单，简化配置，使程序人员注重在业务开发上，节省配置的时间，提升开发效率
 *  Spring Boot Stater提供了开箱即用的整合，配合Maven或者Gradle构建项目
 *  内嵌式Servlet容器（spring-boot-starter-web），默认是tomcat。如果想使用jetty，则需要从spring-boot-starter-web中将spring-bootstarter-tomcat排除，只留有spring-boot-starter-jetty
 *  无代码生成和 xml 配置

##### Spring Boot的核心配置文件 #####

Spring Boot 核心的两个配置文件：

*  bootstrap (. yml 或者 . properties)：boostrap 由父 ApplicationContext 加载的，比 applicaton 优先加载，且 boostrap 里面的属性不能被覆盖；
 *  application (. yml 或者 . properties)：用于 spring boot 项目的自动化配置。

##### Spring Boot是如何实现自动配置的 #####

众所周知，Spring Boot程序中启动类上有一个`@SpringBootApplication`注解，包含了@SpringBootConfiguration（打开是@Configuration），@EnableAutoConfiguration，@ComponentScan注解。点进去看到如下：

@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 {
    
    	/**
    	 * Exclude specific auto-configuration classes such that they will never be applied.
    	 * @return the classes to exclude
    	 */
    	@AliasFor(annotation = EnableAutoConfiguration.class)
    	Class<?>[] exclude() default {};
    
    	/**
    	 * Exclude specific auto-configuration class names such that they will never be
    	 * applied.
    	 * @return the class names to exclude
    	 * @since 1.3.0
    	 */
    	@AliasFor(annotation = EnableAutoConfiguration.class)
    	String[] excludeName() default {};
    
    	/**
    	 * Base packages to scan for annotated components. Use {@link #scanBasePackageClasses}
    	 * for a type-safe alternative to String-based package names.
    	 * @return base packages to scan
    	 * @since 1.3.0
    	 */
    	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
    	String[] scanBasePackages() default {};
    
    	/**
    	 * Type-safe alternative to {@link #scanBasePackages} for specifying the packages to
    	 * scan for annotated components. The package of each class specified will be scanned.
    	 * <p>
    	 * Consider creating a special no-op marker class or interface in each package that
    	 * serves no purpose other than being referenced by this attribute.
    	 * @return base packages to scan
    	 * @since 1.3.0
    	 */
    	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
    	Class<?>[] scanBasePackageClasses() default {};
    
    }

*  @SpringBootConfiguration，这里的启动类标注了@Configuration之后，本身其实也是一个IoC容器的配置类。
 *  @ComponentScan，@ComponentScan的功能其实就是自动扫描并加载符合条件的组件（比如@Component和@Repository等）或者bean定义，最终将这些bean定义加载到IoC容器中。
 *  可以看到有一个注解`@EnableAutoConfiguration`，这个注解就是开启了自动配置，借助@Import的帮助，将所有符合自动配置条件的bean定义加载到IoC容器，在点进去看看

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
    
    	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
    	/**
    	 * Exclude specific auto-configuration classes such that they will never be applied.
    	 * @return the classes to exclude
    	 */
    	Class<?>[] exclude() default {};
    
    	/**
    	 * Exclude specific auto-configuration class names such that they will never be
    	 * applied.
    	 * @return the class names to exclude
    	 * @since 1.3.0
    	 */
    	String[] excludeName() default {};
    
    }

里面最关键的是@Import(EnableAutoConfigurationImportSelector.class)，借助EnableAutoConfigurationImportSelector，@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。接下来我们看一下AutoConfigurationImportSelector，核心代码如下：

@Override
    	public String[] selectImports(AnnotationMetadata annotationMetadata) {
    		if (!isEnabled(annotationMetadata)) {
    			return NO_IMPORTS;
    		}
    		// 获取元数据
    		AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
    				.loadMetadata(this.beanClassLoader);
    		AnnotationAttributes attributes = getAttributes(annotationMetadata);
    		// 扫描具有META-INF/spring.factories文件的jar包
    		List<String> configurations = getCandidateConfigurations(annotationMetadata,
    				attributes);
    		// 去重
    		configurations = removeDuplicates(configurations);
    		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    		checkExcludedClasses(configurations, exclusions);
    		configurations.removeAll(exclusions);
    		configurations = filter(configurations, autoConfigurationMetadata);
    		fireAutoConfigurationImportEvents(configurations, exclusions);
    		return StringUtils.toStringArray(configurations);
    	}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
    			AnnotationAttributes attributes) {
    		// 加载spring.factories
    		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
    				getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    		Assert.notEmpty(configurations,
    				"No auto configuration classes found in META-INF/spring.factories. If you "
    						+ "are using a custom packaging, make sure that file is correct.");
    		return configurations;
    	}

// 扫描具有MEAT-INF/spring.factories文件的jar包，得到所有的配置类
    	public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    		// 自动配置器会跟根据传入的factoryClass.getName()到项目系统路径下所有的spring.factories文件中找到相应的key，从而加载里面的类。
            String factoryClassName = factoryClass.getName();
            return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
        }
    	// 调用loadSpringFactories
        private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
            MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
            if (result != null) {
                return result;
            } else {
                try {
                    Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                    LinkedMultiValueMap result = new LinkedMultiValueMap();
    
                    while(urls.hasMoreElements()) {
                        URL url = (URL)urls.nextElement();
                        UrlResource resource = new UrlResource(url);
                        Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                        Iterator var6 = properties.entrySet().iterator();
    
                        while(var6.hasNext()) {
                            Entry<?, ?> entry = (Entry)var6.next();
                            List<String> factoryClassNames = Arrays.asList(StringUtils.commaDelimitedListToStringArray((String)entry.getValue()));
                            result.addAll((String)entry.getKey(), factoryClassNames);
                        }
                    }
    
                    cache.put(classLoader, result);
                    return result;
                } catch (IOException var9) {
                    throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var9);
                }
            }
        }

至此实现了自动配置。

##### Spring Boot是如何启动的 #####

public ConfigurableApplicationContext run(String... args) {
    		StopWatch stopWatch = new StopWatch();
    		stopWatch.start();
    		ConfigurableApplicationContext context = null;
    		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    		configureHeadlessProperty();
    		// 通过SpringFactoriesLoader查找并加载所有的 SpringApplicationRunListeners，通过调用starting()方法通知所有的SpringApplicationRunListeners：应用开始启动了
    		SpringApplicationRunListeners listeners = getRunListeners(args);
    		listeners.starting();
    		try {
    			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
    					args);
    			// 创建并配置当前应用将要使用的 Environment
    			ConfigurableEnvironment environment = prepareEnvironment(listeners,
    					applicationArguments);
    			configureIgnoreBeanInfo(environment);
    			// SpringBoot应用在启动时会输出一个大大的banner
    			Banner printedBanner = printBanner(environment);
    			// 创建不同的ApplicationContext容器
    			context = createApplicationContext();
    			exceptionReporters = getSpringFactoriesInstances(
    					SpringBootExceptionReporter.class,
    					new Class[] { ConfigurableApplicationContext.class }, context);
    			// 初始化ApplicationContext
    			prepareContext(context, environment, listeners, applicationArguments,
    					printedBanner);
    			// 调用ApplicationContext的refresh()方法
    			refreshContext(context);
    			// 空方法
    			afterRefresh(context, applicationArguments);
    			stopWatch.stop();
    			if (this.logStartupInfo) {
    				new StartupInfoLogger(this.mainApplicationClass)
    						.logStarted(getApplicationLog(), stopWatch);
    			}
    			// 由 SpringApplicationRunListener 来发出 started 消息，完成最终的程序启动
    			listeners.started(context);
    			// 查找当前context中是否注册有CommandLineRunner和ApplicationRunner，如果有则遍历执行它们
    			callRunners(context, applicationArguments);
    		}
    		catch (Throwable ex) {
    			handleRunFailure(context, ex, exceptionReporters, listeners);
    			throw new IllegalStateException(ex);
    		}
    
    		try {
    			// 由 SpringApplicationRunListener 来发出 running 消息，告知程序已运行起来了
    			listeners.running(context);
    		}
    		catch (Throwable ex) {
    			handleRunFailure(context, ex, exceptionReporters, null);
    			throw new IllegalStateException(ex);
    		}
    		return context;
    	}

SpringApplicationRunListener的源码：

class SpringApplicationRunListeners {
    
    	private final Log log;
    
    	private final List<SpringApplicationRunListener> listeners;
    
    	SpringApplicationRunListeners(Log log,
    			Collection<? extends SpringApplicationRunListener> listeners) {
    		this.log = log;
    		this.listeners = new ArrayList<>(listeners);
    	}
    
    	public void starting() {
    		for (SpringApplicationRunListener listener : this.listeners) {
    			listener.starting();
    		}
    	}
    
    	public void environmentPrepared(ConfigurableEnvironment environment) {
    		for (SpringApplicationRunListener listener : this.listeners) {
    			listener.environmentPrepared(environment);
    		}
    	}
    
    	public void contextPrepared(ConfigurableApplicationContext context) {
    		for (SpringApplicationRunListener listener : this.listeners) {
    			listener.contextPrepared(context);
    		}
    	}
    
    	public void contextLoaded(ConfigurableApplicationContext context) {
    		for (SpringApplicationRunListener listener : this.listeners) {
    			listener.contextLoaded(context);
    		}
    	}
    
    	public void started(ConfigurableApplicationContext context) {
    		for (SpringApplicationRunListener listener : this.listeners) {
    			listener.started(context);
    		}
    	}
    
    	public void running(ConfigurableApplicationContext context) {
    		for (SpringApplicationRunListener listener : this.listeners) {
    			listener.running(context);
    		}
    	}
    
    	public void failed(ConfigurableApplicationContext context, Throwable exception) {
    		for (SpringApplicationRunListener listener : this.listeners) {
    			callFailedListener(listener, context, exception);
    		}
    	}
    
    	private void callFailedListener(SpringApplicationRunListener listener,
    			ConfigurableApplicationContext context, Throwable exception) {
    		try {
    			listener.failed(context, exception);
    		}
    		catch (Throwable ex) {
    			if (exception == null) {
    				ReflectionUtils.rethrowRuntimeException(ex);
    			}
    			if (this.log.isDebugEnabled()) {
    				this.log.error("Error handling failed", ex);
    			}
    			else {
    				String message = ex.getMessage();
    				message = (message != null) ? message : "no error message";
    				this.log.warn("Error handling failed (" + message + ")");
    			}
    		}
    	}
    
    }

##### Spring Boot如何启动内置Tomcat #####

*  入口是在`SpringApplication#run`

public ConfigurableApplicationContext run(String... args) {
    		// 省略...
    		
    		//  入口在这里
    		refreshContext(context);
    		
    		//  省略...
    }

*  然后再看`AbstractApplicationContext#refresh.onRefresh()方法`，我们找到在`ServletWebServerApplicationContext`中的实现。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 2]

*  `onRefresh()`方法如下

protected void onRefresh() {
    	super.onRefresh();
    	try {
    		// 这里是创建一个web的容器，常见的有Tomcat和Jetty
    		createWebServer();
    	}
    	catch (Throwable ex) {
    		throw new ApplicationContextException("Unable to start web server", ex);
    	}
    }

*  然后继续看`createWebServer()`方法

private void createWebServer() {
    	WebServer webServer = this.webServer;
    	ServletContext servletContext = getServletContext();
    	if (webServer == null && servletContext == null) {
    		ServletWebServerFactory factory = getWebServerFactory();
    		// 创建一个Tomcat
    		this.webServer = factory.getWebServer(getSelfInitializer());
    	}
    	else if (servletContext != null) {
    		try {
    			getSelfInitializer().onStartup(servletContext);
    		}
    		catch (ServletException ex) {
    			throw new ApplicationContextException("Cannot initialize servlet context", ex);
    		}
    	}
    	initPropertySources();
    }

*  在`TomcatServletWebServerFactory#getWebServer`中可以看到Tomcat是通过new关键字创建的

public WebServer getWebServer(ServletContextInitializer... initializers) {
    	if (this.disableMBeanRegistry) {
    		Registry.disableRegistry();
    	}
    	// new一个Tomcat
    	Tomcat tomcat = new Tomcat();
    	File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
    	tomcat.setBaseDir(baseDir.getAbsolutePath());
    	Connector connector = new Connector(this.protocol);
    	connector.setThrowOnFailure(true);
    	tomcat.getService().addConnector(connector);
    	customizeConnector(connector);
    	tomcat.setConnector(connector);
    	tomcat.getHost().setAutoDeploy(false);
    	configureEngine(tomcat.getEngine());
    	for (Connector additionalConnector : this.additionalTomcatConnectors) {
    		tomcat.getService().addConnector(additionalConnector);
    	}
    	prepareContext(tomcat.getHost(), initializers);
    	return getTomcatWebServer(tomcat);
    }

*  经过以上步骤Tomcat就已经创建好了，接下来看一下Tomcat是如何启动起来的。回到`AbstractApplicationContext#refresh.finishRefresh()`方法，找到在`ServletWebServerApplicationContext`的实现

![在这里插入图片描述][20200525140732611.png]

*  `finishRefresh()`方法如下

protected void finishRefresh() {
    	super.finishRefresh();
    	// 启动
    	WebServer webServer = startWebServer();
    	if (webServer != null) {
    		publishEvent(new ServletWebServerInitializedEvent(webServer, this));
    	}
    }

*  startWebServer()方法如下

private WebServer startWebServer() {
    	WebServer webServer = this.webServer;
    	if (webServer != null) {
    		// TomcatWebServer中实现
    		webServer.start();
    	}
    	return webServer;
    }

*  找到start()方法在TomcatWebServer中的实现

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 3]

public void start() throws WebServerException {
    	synchronized (this.monitor) {
    		if (this.started) {
    			return;
    		}
    		try {
    			addPreviouslyRemovedConnectors();
    			Connector connector = this.tomcat.getConnector();
    			if (connector != null && this.autoStart) {
    				performDeferredLoadOnStartup();
    			}
    			checkThatConnectorsHaveStarted();
    			this.started = true;
    			// 看到这个是不是很熟悉，每次Spring Boot启动的时候都会在控制台打印
    			logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
    					+ getContextPath() + "'");
    		}
    		catch (ConnectorStartFailedException ex) {
    			stopSilently();
    			throw ex;
    		}
    		catch (Exception ex) {
    			if (findBindException(ex) != null) {
    				throw new PortInUseException(this.tomcat.getConnector().getPort());
    			}
    			throw new WebServerException("Unable to start embedded Tomcat server", ex);
    		}
    		finally {
    			Context context = findContext();
    			ContextBindings.unbindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
    		}
    	}
    }

##### Spring Boot定义不同的环境配置 #####

applcation.yml
    
    application-dev.yml
     
    application-test.yml
     
    application-prod.yml

通过`@Profile("dev")`来切换不同的环境配置

##### Spring Boot如何实现跨域 #####

@Configuration
    @EnableWebMvc
    public class CorsConfig implements WebMvcConfigurer {
    
      @Override
      public void addCorsMappings(CorsRegistry registry) {
        // 设置允许跨域的路径
        registry.addMapping("/**")
            // 设置允许跨域请求的域名
            .allowedOrigins("*")
            // 是否允许证书 不再默认开启
            .allowCredentials(true)
            // 设置允许的方法
            .allowedMethods("*")
            // 跨域允许时间
            .maxAge(3600);
      }
    }

##### Spring Boot实现多数据源配置 #####

[请参考这篇文章][Link 3]

##### Spring Boot自定义Starter #####

首先创建一个Maven工程，因为自定义的Starter是不能有程序启动入口的，所以不要把自定义的pom写成一个可以启动的项目。

*  首先定义pom

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.bazooka</groupId>
        <artifactId>demo-spring-boot-starter</artifactId>
        <version>1.0-SNAPSHOT</version>
    
    
        <dependencies>
            <dependency>
            	
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
            </dependency>
        </dependencies>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
    
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>2.3.0.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    </project>

*  然后定义一个service

public class DemoService {
    
        public String wrap(String name) {
            return name + "要注意发量哦。";
        }
    }

*  这一步是重点，定义一个`AutoConfigure`类

@Configuration
    @ConditionalOnClass(DemoService.class)
    public class DemoServiceAutoConfigure {
    
        @Bean
        @ConditionalOnMissingBean
        DemoService demoService() {
            return new DemoService();
        }
    }

*  然后在resources下创建文件夹`META-INF`，并在`META-INF`下创建文件`spring.factories` ，内容如下：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    com.bazooka.service.DemoService

参考Spring Boot自动配置的原理，程序启动的时候会扫描MEAT-INF/spring.factories（spring.factories声明具体自动配置），得到所有的自动配置类。

到这儿，我们的配置自定义的starter就写完了 ，通过`mvn:install`安装到本地。

*  测试一下我们的自定义starter

写一个Spring Boot Web的程序，在pom中引入我们刚刚定义好的starter

<dependency>
    	<groupId>com.bazooka</groupId>
    	<artifactId>demo-spring-boot-starter</artifactId>
    	<version>1.0-SNAPSHOT</version>
    </dependency>

然后写一个rest API，通过`@Autowired`的方式自动注入。

@RestController
    @SpringBootApplication
    public class SpringBootStarterDemoApplication {
    
        @Autowired
        DemoService demoService;
    
        public static void main(String[] args) {
            SpringApplication.run(SpringBootStarterDemoApplication.class, args);
        }
    
        @GetMapping("/sayHello")
        public String sayHello(String name) {
            return demoService.wrap(name);
        }
    }

运行结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200218153558956.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200525101447219.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx,size_16,color_FFFFFF,t_70
[Link 1]: https://blog.csdn.net/wangchengming1/article/details/104357744
[Link 2]: https://blog.csdn.net/wangchengming1/article/details/95626567
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200525134006316.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx,size_16,color_FFFFFF,t_70
[20200525140732611.png]: https://img-blog.csdnimg.cn/20200525140732611.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200525141021168.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx,size_16,color_FFFFFF,t_70
[Link 3]: https://www.jianshu.com/p/34730e595a8c
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200529092122237.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx,size_16,color_FFFFFF,t_70