我们知道SpringBoot的理念就是约定大于配置，这也使得我们在开发应用程序的过程更加便捷，以前的大量XML配置直接是噩梦呀，现在出现了SpringBoot明显降低了开发成本，而且大量的注解的使用帮我们省略掉了很多代码。本篇文章主要探究的是SpringBoot是如何实现自动配置并且如何加载配置Bean的，其实主要就是探究@EnableAutoConfiguration注解究竟发挥了怎样的作用。



# @EnableAutoConfiguration

@SpringBootApplication其实是三个注解的组合体，这三个注解中@Configuration和@ComponentScan对我们来说并不陌生，今天我们主要探究的是`@EnableAutoConfiguration` 。

```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	...
}
```

其中最关键的要属@Import(AutoConfigurationImportSelector.class)，借助AutoConfigurationImportSelector，@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器中。

借助于Spring框架原有的一个工具类：SpringFactoriesLoader的支持，@EnableAutoConfiguration可以智能的自动配置功效才得以大功告成！

![mark](https://img.zouchanglin.cn///20200425/i8PydmvtoSrV.png)

在AutoConfigurationImportSelector类中可以看到通过SpringFactoriesLoader.loadFactoryNames()
把spring-boot-autoconfigure.jar/META-INF/spring.factories中每一个xxxAutoConfiguration文件都加载到容器中，spring.factories文件里每一个xxxAutoConfiguration文件一般都会有下面的条件注解。
* @ConditionalOnClass ： classpath中存在该类时起效
* @ConditionalOnMissingClass ： classpath中不存在该类时起效
* @ConditionalOnBean ： DI容器中存在该类型Bean时起效
* @ConditionalOnMissingBean ： DI容器中不存在该类型Bean时起效
* @ConditionalOnSingleCandidate ： DI容器中该类型Bean只有一个或@Primary的只有一个时起效
* @ConditionalOnExpression ： SpEL表达式结果为true时
* @ConditionalOnProperty ： 参数设置或者值一致时起效
* @ConditionalOnResource ： 指定的文件存在时起效
* @ConditionalOnJndi ： 指定的JNDI存在时起效
* @ConditionalOnJava ： 指定的Java版本存在时起效
* @ConditionalOnWebApplication ： Web应用环境下起效
* @ConditionalOnNotWebApplication ： 非Web应用环境下起效

# SpringFactoriesLoader

SpringFactoriesLoader属于Spring框架私有的一种扩展方案（类似于Java的SPI方案java.util.ServiceLoader)，其主要功能就是从指定的配置文件META-INF/spring-factories加载配置，spring-factories是一个典型的java properties文件，只不过Key和Value都是Java类型的完整类名，比如：

```java
xpu.MyService = xpu.MyServiceImpl
```

对于@EnableAutoConfiguration来说，SpringFactoriesLoader的用途稍微不同一些，其本意是为了提供SPI扩展的场景，而在@EnableAutoConfiguration场景中，它更多提供了一种配置查找的功能支持，即根据@EnableAutoConfiguration的完整类名org.springframework.boot.autoconfig.EnableAutoConfiguration作为查找的Key，获得对应的一组@Configuration类。

SpringFactoriesLoader是一个抽象类，类中定义的静态属性定义了其加载资源的路径public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"，此外还有三个静态方法

* loadFactories：加载指定的factoryClass并进行实例化。
* loadFactoryNames：加载指定的factoryClass的名称集合。
* instantiateFactory：对指定的factoryClass进行实例化。


![mark](https://img.zouchanglin.cn///20200425/1bRT86Y52Um1.png)

loadFactories还是调用了loadFactoryNames与instantiateFactory方法。loadFactories方法首先获取类加载器，然后调用loadFactoryNames方法获取所有的指定资源的名称集合、接着调用instantiateFactory方法实例化这些资源类并将其添加到result集合中。最后调用AnnotationAwareOrderComparator.sort方法进行集合的排序。

我们可以看一下SpringBoot的自动配置的Bean有哪些，见下图：

![mark](https://img.zouchanglin.cn///20200425/13RjuG9rj5kB.png)

# 自动配置示例

下面结合一个例子来加深理解，例子展示的是当项目启动时如果某个类存在就自动配置这个Bean，并且这个属性可以在application.properties中配置。新建一个Maven项目，pom.xml文件如下：

![mark](https://img.zouchanglin.cn///20200425/e9XcsiWpXCXq.png)

pom.xml

```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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>xpu.tim</groupId>
    <artifactId>autoconfig-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.0.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <version>2.0.4.RELEASE</version>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>
```

Person.java

```java
package xpu.edu.tim;

public class Person {
    private String name;

    public String sayName(){
        return "My Name is " + name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```

PersonProperties.java

```java
package xpu.edu.tim;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "person") //获取属性值
public class PersonProperties {
    private static final String NAME = "Jock.Tim";

    private String name = NAME ;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```

PersonAutoConfiguration.java

```java
package xpu.edu.tim;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//为带有@ConfigurationProperties注解的Bean提供有效的支持。
//这个注解可以提供一种方便的方式来将带有@ConfigurationProperties注解的类注入为Spring容器的Bean。
@EnableConfigurationProperties(PersonProperties.class)//开启属性注入,通过@autowired注入
@ConditionalOnClass(Person.class)//判断这个类是否在classpath中存在，如果存在，才会实例化一个Bean
@ConditionalOnProperty(prefix="person", value="enabled", matchIfMissing = true)
public class PersonAutoConfiguration {
    @Autowired
    private PersonProperties personProperties;

    @Bean
    @ConditionalOnMissingBean(Person.class)//容器中如果没有Person这个类,那么自动配置这个Person
    public Person person() {
        Person person = new Person();
        person.setName(personProperties.getName());
        return person;
    }
}
```

spring.factories

```ini
org.springframework.boot.autoconfigure.EnableAutoConfiguration=xpu.edu.tim.PersonAutoConfiguration
```

最后使用`mvn package`将上面项目打包，使用`mvn install:install-file`命令将打包文件上传到本地Maven仓库进行测试，下面再新建一个Maven项目用于测试。 

```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.2.6.RELEASE</version>
        <relativePath/> 
    </parent>
    <groupId>edu.tim</groupId>
    <artifactId>spring-boot-start</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-start</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        
        <dependency>
            <groupId>xpu.tim</groupId>
            <artifactId>autoconfig-demo</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
```

![mark](https://img.zouchanglin.cn///20200425/LCLp6i3PGsBo.png)

IndexController.java

```java
@RestController
@RequestMapping("/")
public class IndexController {
    @Autowired
    private Person person;

    @GetMapping
    public String index(){
        return person.sayName();
    }
}
```

![mark](https://img.zouchanglin.cn///20200425/RbeMq9tjH9aQ.png)

SpringBoot自动配置原理

![mark](https://img.zouchanglin.cn///20200405/HbNPDVawlHpU.png)

ICO容器的结构如上图所示，首先要让IOC容器去读取Bean的配置信息，并在容器中生成一份相应的Bean定义注册表，根据这张注册表去实例化Bean，装配好Bean之间的依赖关系，为上层提供准备就绪的环境，Spring提供一个配置文件描述Bean还有Bean之间的依赖关系，利用Java语言的反射功能实例化Bean并建立Bean之间的依赖关系。



# SpringIOC容器支持的功能

1、依赖注入

2、依赖检查

3、自动装配

4、支持集合

5、指定初始化和销毁的方法

6、支持回调方法，但是需要实现Spring的接口，略带有侵入性

其中最核心的功能就是依赖注入和自动装配了。

# SpringIOC源码分析

Spring 作者 Rod Johnson 设计了两个接口用以表示容器。BeanFactory和ApplicationContext， BeanFactory 粗暴简单，可以理解为就是个 HashMap，Key 是BeanName，Value 是 Bean 实例。通常只提供注册（put），获取（get）这两个功能。我们可以称之为 “低级容器”。  ApplicationContext 可以称之为 “高级容器”。因为他比 BeanFactory 多了更多的功能。他继承了多个接口。因此具备了更多的功能。

## BeanDefinition

BeanDefinition与Bean的关系, 就好比类与对象的关系，类在spring的数据结构就是BeanDefinition。根据BeanDefinition得到的对象就是我们需要的Bean。 理解Bean与BeanDefinition是理解spring的整个架构的基础与关键， BeanDefinition接口是顶级基础接口，用来描述Bean，里面存放Bean元数据，比如Bean类名、scope、属性、构造函数参数列表、依赖的bean、是否是单例类、是否是懒加载等一些列信息。

BeanDefinition继承的两个接口：

- **BeanMetadataElement接口**：BeanDefinition元数据，返回该Bean的来源
- **AttributeAccessor接口**：提供对BeanDefinition属性操作能力，

继承或实现BeanDefinition的接口：

- **AbstractBeanDefinition类**：抽象类统一实现了BeanDefinition定义的一部分操作，可以说是定义了BeanDefinition很多默认的属性。 正是在AbstractBeanDefinition基础上， Spring衍生出了一些列BeaDefinition。

这里我们可以关注下重写的equals()、hashcode()、toString()方法

此外initMethodName属性，destroyMethodName 属性，这两个属性bean的生命周期有关，此处只提一句，后续讲解。

接下来，我们看看从AbstractBeanDefinition上衍生出来的几个类

- **RootBeanDefinition**: 代表一个xml，java Config来的BeanDefinition
- **ChildBeanDefinition**: 可以让子BeanDefinition定义拥有从父母哪里继承配置的能力
- **GenericBeanDefinition:** spring2.5后注册bean首选的是GenericBeanDefinition。GenericBeanDefinition允许动态的设置父bean.GenericBeanDefinition可以作为RootBeanDefinition与ChildBeanDefinition的替代品。
- **AnnotatedBeanDefinition接口**： 表示注解类型BeanDefinition。有两个重要的属性，AnnotationMetadata，MethodMetadata分别表示BeanDefinition的注解元信息和方法元信息 实现了此接口的BeanDefinition可以获取到注解元数据和方法元数据。
- **AnnotatedGenericBeanDefinition类**: 表示@Configuration注解注释的BeanDefinition类
- **ScannedGenericBeanDefinition类**: 表示@Component、@Service、@Controller等注解注释的Bean类

## BeanDefinitionRegistry

提供向IOC容器注册BeanDefinition对象的方法，将定义Bean 的资源文件解析成 BeanDefinition 后需要将其注入容器中，这个过程就是由 BeanDefinitionRegistry 来完成。 BeanDefinitionRegistry 继承了 AliasRegistry 接口，其核心子类有三个：SimpleBeanDefinitionRegistry、DefaultListableBeanFactory、GenericApplicationContext。

![mark](https://img.zouchanglin.cn///20200405/E5QxQebdaucd.png)

* AliasRegistry：  用于别名管理的通用型接口，作为 BeanDefinitionRegistry 的顶层接口。AliasRegistry 定义了一些别名管理的方法。
* BeanDefinitionRegistry：BeanDefinition 的注册接口，如 RootBeanDefinition 和 ChildBeanDefinition。它通常由 BeanFactories 实现，在 Spring 中已知的实现者为：DefaultListableBeanFactory 和 GenericApplicationContext。BeanDefinitionRegistry 是 Spring 的 Bean 工厂包中唯一封装 BeanDefinition 注册的接口。BeanDefinitionRegistry 接口定义了关于 BeanDefinition 注册、注销、查询等一系列的操作。
* SimpleBeanDefinitionRegistry：SimpleBeanDefinitionRegistry 是 BeanDefinitionRegistry 一个简单的实现，它还继承 SimpleAliasRegistry（ AliasRegistry 的简单实现），它仅仅只提供注册表功能，无工厂功能。SimpleBeanDefinitionRegistry 使用 ConcurrentHashMap 来存储注册的 BeanDefinition。
* DefaultListableBeanFactory： DefaultListableBeanFactory，ConfigurableListableBeanFactory（其实就是 BeanFactory ） 和BeanDefinitionRegistry 接口的默认实现：一个基于BeanDefinition元数据的完整 Bean工厂。所以相对于SimpleBeanDefinitionRegistry而言，DefaultListableBeanFactory则是一个具有注册功能的完整Bean工厂。它同样是用ConcurrentHashMap数据结构来存储注册的BeanDefinition。

## BeanFactory

提供IOC的配置机制、包含Bean的各种定义，便于实例化Bean、建立Bean之间的依赖关系、Bean生命周期的控制等功能。 BeanFactory是个Factory，也就是IOC容器或对象工厂，FactoryBean是个Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似，下图是BeanFactory的体系结构：

![mark](https://img.zouchanglin.cn///20200407/bWSznXkawhdX.png)

ListableBeanRegistry，该接口定义了访问容器中并基本信息的若干方法。查看Bean的个数，获取某一类型Bean的配置名，查看容器中是否包括某一Bean等方法。

HierarchicalBeanFactory，即父子级联ICO接口，此容器可以通过接口方法访问父容器，通过HierarchicalBeanFactory接口，Spring得IOC容器可以建立父子关联得容器体系，子容器可以访问父容器中的Bean，但是父容器是不能访问子容器中的Bean的。Spring使用父子容器实现了很多功能，比如在SpringMVC中，展现层的Bean位于一个子容器中，而业务层和持久层的Bean位于父容器中，这样展现层的Bean就可以引用业务层和持久层的Bean，而持久层和业务层的却看不到展现层的Bean。

ConfigurableBeanFactory，它在SpringCore中是一个很重要的接口，增强了IOC容器的可定制性，它定义了设置类加载器、属性编辑器、以及属性初始化后置处理器等方法。

AutowireCapableFactory，它定义了将容器中的Bean按照某种规则，比如按照名称匹配，按照类型匹配等，按照这些规则，对Bean进行自动装配。

SingletonBeanRegistry，它允许在运行期间向容器注册Singleton实例Bean的方法，通过这些接口也证明了BeanFactory体系确实是提供了IOC的基础，即依赖注入和Bean的装载等功能。

# BeanFactory与ApplicationContext

BeanFactory是Spring框架的基础设施，面向SpringApplicationContext面向使用Spring框架的开发者。

ApplicationContext的功能(继承多个接口)

* BeanFactory：能够管理、装配Bean
* ResourcePatternResolver：能够加载资源文件
* MessageSource：能够实现国际化等功能
* ApplicationEventPublisher：能够注册监听器,实现监听机制

ApplicationContext 包含 BeanFactory 的所有特性，通常推荐使用前者。但是也有一些限制情形，比如移动应用内存消耗比较严苛，在那些情景中，使用更轻量级的 BeanFactory 是更合理的。然而，在大多数企业级的应用中，ApplicationContext 是你的首选。

# SpringIOC应用示例

下面演示一个我们手动装配的例子：

Person.java

```java
public class Person {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```

ApplicationConfig.java

```java
@Configuration
public class ApplicationConfig {
    @Bean(name = "person")
    public Person initPerson(){
        Person person = new Person();
        person.setId(1);
        person.setName("Tim");
        return person;
    }
}
```

SpringStudyApplication.java

```java
@SpringBootApplication
public class SpringStudyApplication {
    public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(SpringStudyApplication.class, args);
        Person person = ctx.getBean(Person.class);
        System.out.println("Name is " + person.getName());
    }
}
```

![mark](https://img.zouchanglin.cn///20200407/wpaFUD9Rc263.png)

接下来使用另一种方式，这样就不需要ApplicationConfig了， @SpringBootApplication已经含有了@ComponentScan注解，即已经拥有了扫描器的功能：

Person.java

```java
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("person")
public class Person {
    @Value("1")
    private Integer id;
    
    @Value("Tim")
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```

![mark](https://img.zouchanglin.cn///20200407/ujItcphs1QzJ.png)

现在看看如果是多个实现类，如何自动注入呢？

```java
public interface Pet {
    void move();
}

@Component
public class Dog implements Pet {
    @Override
    public void move() {
        System.out.println("Running...");
    }
}

@Component
public class Bird implements Pet {
    @Override
    public void move() {
        System.out.println("flying...");
    }
}

@Component("person")
public class Person {
    private Pet pet;

    public Person(Pet pet) {
        this.pet = pet;
    }
    
    ...
}
```

此时应该注入哪个呢？其实IOC容器也不知道该注入谁，只能报错。

```
Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed
```

@Reource（默认按名称装配，当找不到与名称匹配的bean才会按类型装配）, @Autowired（默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解和@Primary注解一起使用） 

@Primary自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常

@Qualifier的意思是合格者，通过这个标示，表明了哪个实现类才是我们所需要的

![mark](https://img.zouchanglin.cn///20200407/zf3z9rFBmetT.png)

SpringIOC原理与应用

![mark](https://img.zouchanglin.cn///20200405/IHCyMIrsdTrx.png)

SpringIOC是Spring Core最核心的部分，要了解控制反转(Inversion of Control)，我觉得有必要先了解软件设计的一个重要思想：依赖倒置原则。

1、高层模块不应该依赖底层模块，二者都应该依赖抽象
2、抽象不应该依赖细节，细节应该依赖抽象。
3、依赖倒置的中心思想是面向接口编程。
4、依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础搭建的架构要稳定的多。
5、使用接口或抽象类的目的是指定好规范，而不涉及任何具体操作，展现细节的任务交给他们的实现类来完成。



# 依赖注入DI

现在假设我们需要设计一个行李箱，行李箱依赖于箱体，箱体依赖于底盘，底盘依赖于轮子。

![mark](https://img.zouchanglin.cn///20200405/r4uc3slWmxkX.png)

现在假设轮子需要按尺寸需求更改，那么底盘也得改，箱体也得改，行李箱也要改。代码如下：

![mark](https://img.zouchanglin.cn///20200405/GVLjGXVrytM1.png)

现在如果需要把轮子得大小改为动态可调整的，那么上层代码也得跟着变，由此我们可以看到，仅仅是为了修改轮子的构造函数，这种设计却需要修改整个上层所有类的构造函数！在软件工程中，这样的设计几乎是不可维护的——在实际工程项目中，有的类可能会是几千个类的底层，如果每次修改这个类，我们都要修改所有以它作为依赖的类，那软件的维护成本就太高了，这就是典型的上层建筑依赖下层建筑。

所以我们需要进行控制反转（IoC），及上层控制下层，而不是下层控制着上层。我们用依赖注入（Dependency Injection）这种方式来实现控制反转。所谓依赖注入，就是把底层类作为参数传入上层类，实现上层类对下层类的控制。这里我们用**构造方法传递的依赖注入方式** 重写各个类的构造函数：

![mark](https://img.zouchanglin.cn///20200405/SsDxCFrYxffR.png)

依赖注入是如何解决这个问题的呢？我们可以先设计行李箱箱，根据行李箱设计箱体，根据箱体设计底盘，根据底盘设计轮子，如下图所示：

![mark](https://img.zouchanglin.cn///20200405/vg7DOMGtuRht.png)

所以，依赖注入即把底层类作为参数传递给上层类，实现上层对下层的控制。

![mark](https://img.zouchanglin.cn///20200405/LSU5tWQee5W8.png)

这样即实现了底层类的更改不会影响到上层类的修改，增加了代码的可维护性。 这里我们是采用的构造函数传入的方式进行的依赖注入。其实还有另外三种方法：Setter传递和接口传递和注解的方式。这里就不多讲了，核心思路都是一样的，都是为了实现控制反转。 

# IOC与DI、DL的关系

![mark](https://img.zouchanglin.cn///20200405/ITwmaCV4UJEF.png)

EJB即使用DL来实现的IOC，DI是当今IOC的主流实现。 DI提供了Setter注入、接口注入、注解注入、构造器注入等多种注入方式。依赖倒置原则和IOC的关系是怎样的呢？

![mark](https://img.zouchanglin.cn///20200405/IHCyMIrsdTrx.png)

依赖倒置原则、IOC、DI、以及spring IOC容器，这四者的关系就是：依赖倒置原则上是一种思想，它主要含义是高层模块，不应该依赖于低层模块，两者都应该依赖其抽象。正是依赖倒置原则的指导，才有了IOC控制反转的思路，需要怎么实现这个思路呢？就离不开依赖注入之类的支撑，Spring等框架，基于IOC才提出了容器的概念。对于IOC来说。最重要的就是容器把容器管理的Bean的生命周期进行控制依赖注入，那什么是控制反转容器IOC container呢？其实就是承载对象的容器，便于组装对象，避免在各处使用new来创建类，并且可以做到统一维护。

如果我们一步一步去new的话，就会是图中的上面的情况，需要根据构造函数一步一步来注入：

![mark](https://img.zouchanglin.cn///20200405/VezV8pS1auX5.png)

而ICO容器注入的过程如图中下面的部分所示，先查找对象的依赖关系，然后自底向上进行注入。

![mark](https://img.zouchanglin.cn///20200405/UDJ7CpsvV19t.png)

如何理解SpringIOC

本篇文章主要记录了JUC的四个并发工具类，闭锁CountDownlatch、栅栏CyclicBarrier、信号量Semaphore、交换器Exchanger。CountDownlatch通常用于主线程等待其他任务线程执行完毕的场景；CyclicBarrier主要阻塞当前线程，等待其他线程（大家无论谁先跑到A点，必须要等其他线程也到达了A点，大家才能继续）。信号量Semaphore可以用来控制同时访问特定资源的线程数量（比如100个线程只能有10个线程可以获得MySQL连接）。交换器Exchanger很少用，只适用于两个线程在同步点交换数据的场景（如下图）。

![mark](https://img.zouchanglin.cn///20200404/xTzG4uGsytB7.png)



# 闭锁CountDownlatch

CountDownLatch也叫闭锁，使得一(多)个主线程必须等待其他线程完成操作后再执行。 CountDownLatch内部维护一个计数器(父类的int state)，主线程先执行await方法，如果此时计数器大于0，则阻塞等待。当一个线程完成任务后，计数器值减1。直到计数器为0时，表示所有的线程已经完成任务，等待的主线程被唤醒继续执行。 

CountDownLatch实现主要基于Java同步器AQS，关于AQS的分析可以看我这篇文章：[《ReentrantLock与AQS》](https://zouchanglin.cn/2020/04/01/3865338567.html) ，countDown方法核心实现如下：

```java
public void countDown() {
	sync.releaseShared(1);
}

public final boolean releaseShared(int arg) {
	// countDownLatch -> tryReleaseShared
	if (tryReleaseShared(arg)) {
		doReleaseShared();
		return true;
	}
	return false;
}

private void doReleaseShared() {
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue; // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue; // loop on failed CAS
        }
        if (h == head) // loop if head changed
            break;
    }
}
```

CountDownlatch的使用案例，下面使用三个线程来打印三个List，三个线程任务都完成得时候才输出Print Task Finish！

```java
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("AAA", "BBB", "CCC");
        List<String> list2 = Arrays.asList("DDD", "EEE", "FFF");
        List<String> list3 = Arrays.asList("GGG", "HHH", "III");

        CountDownLatch countDownLatch = new CountDownLatch(3);
        new Thread(()->{
            for (String string: list1) {
                System.out.println(Thread.currentThread().getName() + ":" + string);
            }
            countDownLatch.countDown();
        }).start();
        new Thread(()->{
            for (String string: list2) {
                System.out.println(Thread.currentThread().getName() + ":" + string);
            }
            countDownLatch.countDown();
        }).start();
        new Thread(()->{
            for (String string: list3) {
                System.out.println(Thread.currentThread().getName() + ":" + string);
            }
            countDownLatch.countDown();
        }).start();
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Print Task Finish！");
    }
}
```

![mark](https://img.zouchanglin.cn///20200404/oWEVgfnsaXQq.png)

# 栅栏CyclicBarrier

CyclicBarrier：阻塞当前线程，等待其他线程。等待其它线程，且会阻塞自己当前线程，所有线程必须同时到达栅栏位置后才能继续执行；所有线程到达栅栏处，可以触发执行另外一个预先设置的线程。

```java
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) throws InterruptedException {
        new CyclicBarrierDemo().go();
    }

    private void go() throws InterruptedException {
        //初始化栅栏得参与者数为3
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        new Thread(new Task(cyclicBarrier), "Thread1").start();
        Thread.sleep(1000);
        new Thread(new Task(cyclicBarrier), "Thread2").start();
        Thread.sleep(1000);
        new Thread(new Task(cyclicBarrier), "Thread3").start();
    }

    class Task implements Runnable{
        private CyclicBarrier cyclicBarrier;

        public Task(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("线程" + Thread.currentThread().getName()
                    + "已经送达"
                    + System.currentTimeMillis());
            try {
                cyclicBarrier.await();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程" + Thread.currentThread().getName()
                    + "开始处理"
                    + System.currentTimeMillis());
        }
    }
}
```

![mark](https://img.zouchanglin.cn///20200404/AcmJnEW4JTJW.png)

# 信号量Semaphore

Semaphore也叫信号量，在JDK1.5被引入，**可以用来控制同时访问特定资源的线程数量**，通过协调各个线程，以保证合理的使用资源。Semaphore内部维护了一组虚拟的许可，许可的数量可以通过构造函数的参数指定。

访问特定资源前，必须使用acquire方法获得许可，如果许可数量为0，该线程则一直阻塞，直到有可用许可。访问资源后，使用release释放许可。Semaphore和ReentrantLock类似，获取许可有公平策略和非公平许可策略，默认情况下使用非公平策略。

信号量Semaphore得应用场景：Semaphore可以用来做流量分流，特别是对公共资源有限的场景，比如数据库连接。假设有这个的需求，读取几万个文件的数据到数据库中，由于文件读取是IO密集型任务，可以启动几十个线程并发读取，但是数据库连接数只有10个，这时就必须控制最多只有10个线程能够拿到数据库连接进行操作。这个时候，就可以使用Semaphore做流量控制。 

```java
package thread_study;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreDemo {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        //只能5个线程同时访问
        Semaphore semaphore = new Semaphore(5);
        //模拟20个客户端访问
        for (int i = 0; i < 20; i++) {
            final int NO = i;
            pool.execute(()->{
                try {
                    //获取许可
                    semaphore.acquire();
                    System.out.println("Accessing: " + NO);
                    Thread.sleep((long)(Math.random() * 10000));
                    //访问完毕后释放
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        //退出线程池
        pool.shutdown();
    }
}
```

![mark](https://img.zouchanglin.cn///20200404/Wzr6IyFi8aX7.png)

# 交换器Exchanger

Exchanger（交换者）是一个用于线程间数据交换协作的工具类。它提供一个同步点，在这个同步点多个线程间两两之间线程可以交换彼此的数据。这两个线程通过exchange方法交换数据， 如果第一个线程先执行exchange方法，它会一直等待第二个线程也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。 

![mark](https://img.zouchanglin.cn///20200404/xTzG4uGsytB7.png)

```java
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ExchangerDemo {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        threadPool.execute(()->{
            try {
                //男生对女生说的话
                String girl = exchanger.exchange("我其实暗恋你很久了....");
                System.out.println("女生说: " + girl);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        threadPool.execute(()->{
            try {
                System.out.println("女生慢慢的从教室走出来.... ");
                TimeUnit.SECONDS.sleep(3);
                //男生对女生说的话
                String boy = exchanger.exchange("我很喜欢你....");
                System.out.println("男生说：" + boy);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        threadPool.shutdown();
    }
}
```

![mark](https://img.zouchanglin.cn///20200404/oqBO0dm5QiIQ.png)

JUC的四个并发工具类

Fork/Join框架就是在必要的情况下，将一个大任务，进行拆分（fork）成若千个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行join汇总。

![mark](https://img.zouchanglin.cn///20200404/ChkDGz2ekXrP.png)

ForkJoin框架采用`工作窃取`模式(work-stealing) :当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上，在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行。这种方式减少了线程的等待时间，提高了性能。



# ForkJoin框架

下面是一个很简单的示例，即用Fork/Join框架来计算0-500亿的和，普通For用时13745毫秒，Fork/Join框架用时8846毫秒，而且还有拆装箱的时间，足以看出Fork/Join框架的优势。

```java
import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class TestForkJoinPool {
    public static void main(String[] args) {
        Instant start = Instant.now();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinSunCalculate(0L, 50000000000L);
        Long invoke = forkJoinPool.invoke(task);
        System.out.println(invoke);
        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis()); //8846
    }

    public static void main(String[] args) {
        Instant start = Instant.now();
        long sum = 0L;
        for (long i = 0; i < 50000000000L; i++) {
            sum += i;
        }
        System.out.println(sum);
        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis()); //13745
    }
}

class ForkJoinSunCalculate extends RecursiveTask<Long> {
    private long start;
    private long end;

    //临界值
    private static final long VALUE = 10000L;

    public ForkJoinSunCalculate(long start, long end){
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        long length = end - start;
        if(length <= VALUE){
            long sum = 0L;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else{
            long middle = (end - start) / 2 + start;
            ForkJoinSunCalculate leftCalculate = new ForkJoinSunCalculate(start, middle);
            leftCalculate.fork(); //进行拆分，同时压入线程队列

            ForkJoinSunCalculate rightCalculate = new ForkJoinSunCalculate(middle + 1, end);
            rightCalculate.fork();//进行拆分，同时压入线程队列

            return leftCalculate.join() + rightCalculate.join();
        }
    }
}
```

用JDK8的特性stream谁快呢？

```java
import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

public class TestForkJoinPool {
    public static void main(String[] args) {
        Instant start = Instant.now();
        long sum = LongStream.rangeClosed(0L, 50000000000L)
                .parallel()
                .reduce(0L, Long::sum);
        System.out.println(sum);
        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis()); //5156
    }
}
```

其实这简单的计算还是stream更快，底层优化太多了。

# ReadWriteLock

ReadWriteLock维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有writer，读取锁可以由多个reader线程同时保持，写入锁是独占的。

ReadWriteLock读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作。

```java
package thread_study;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

//读写锁
public class TestReadWriteLock {
    public static void main(String[] args) {
        ReadWriteLockDemo writeLockDemo = new ReadWriteLockDemo();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                writeLockDemo.set(i);
            }
        }, "Write Thread").start();
        for (int i = 0; i < 20; i++) {
            new Thread(writeLockDemo::get, "Read Thread").start();
        }
    }
}

class ReadWriteLockDemo{
    private int number = 0;
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public void get(){
        lock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName() + " : " + number);
        }finally {
            lock.readLock().unlock();
        }
    }

    public void set(int number){
        lock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName());
            this.number = number;
        }finally {
            lock.writeLock().unlock();
        }
    }
}
```