Hello，今天给各位童鞋们分享Spring IOC，赶紧拿出小本子记下来吧！
1. IoC原理
IoC全称Inversion of Control，直译为控制反转。
为什么要使用IoC？
我们假定一个在线书店，通过BookService获取书籍：
public class BookService {
private HikariConfig config = new HikariConfig();
private DataSource dataSource = new HikariDataSource(config);
public Book getBook(long bookId) {
try (Connection conn = dataSource.getConnection()) {
...
return book;
}
}
}
为了从数据库查询书籍，BookService持有一个DataSource。为了实例
HikariDataSource，又不得不实例化一个HikariConfig。现在，我们继续编
UserService获取用户：
public class UserService {
private HikariConfig config = new HikariConfig();
private DataSource dataSource = new HikariDataSource(config);
public User getUser(long userId) {
try (Connection conn = dataSource.getConnection()) {
...
return user;
}
}
}
因为UserService也需要访问数据库，因此，我们不得不也实例化一个HikariDataSource。
每一次调用方法， 都需要实例化一个HikariDataSource，容易造成资源浪费。如果用某种方法实现了共享资源，那么怎么确保在所有功能完整的情况下，销毁以释放资源呢？
因此，核心问题是：
谁负责创建组件？
谁负责根据依赖关系组装组件？
销毁时，如何按依赖顺序正确销毁？
解决这一问题的核心方案就是IoC。
传统的应用程序中，**控制权在程序本身，**程序的控制流程完全由开发者控制，即在程序内部进行实例化类。
而在IoC模式下，控制权发生了反转，即从应用程序转移到了IoC容器，所有组件不再由应用程序自己创建和配置，而是由IoC容器负责，这样，应用程序只需要直接使用已经创建好并且配置好的组件。
为了能让组件在IoC容器中被“装配”出来，需要某种“注入”机制，例如，BookService自己并不会创建DataSource，而是等待外部通过setDataSource()方法来注入一个DataSource：
public class BookService {
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
}
不直接new一个DataSource，而是注入一个DataSource，这个小小的改动虽然简单，却带来了一系列好处：
BookService不再关心如何创建DataSource，因此，不必编写读取数据库配置之类的代码；
DataSource实例被注入到BookService，同样也可以注入到UserService，因此，共享一个组件非常简单；
测试BookService更容易，因为注入的是DataSource，可以使用内存数据库，而不是真实的MySQL配置。
因此，IoC又称为依赖注入（DI：Dependency Injection），它解决了一个最主要的问题：将组件的创建+配置与组件的使用相分离，并且，由IoC容器负责管理组件的生命周期。
因为IoC容器要负责实例化所有的组件，因此，有必要告诉容器如何创建组件，以及各组件的依赖关系。一种最简单的配置是通过XML文件来实现，例如：
上述XML配置文件指示IoC容器创建3个JavaBean组件，并把id为dataSource的组件通过属性dataSource（即调用setDataSource()方法）注入到另外两个组件中。
在Spring的IoC容器中，我们把所有组件统称为JavaBean，即配置一个组件就是配置一个Bean。
依赖注入（DI：Dependency Injection）方式
从上面的代码我们可以得知，依赖注入可以通过set()方法实现，但同时我们也可以通过构造方法来实现：
//set()方法
public class BookService {
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
}
//构造器方法
public class BookService {
private DataSource dataSource;
public BookService(DataSource dataSource) {
this.dataSource = dataSource;
}
}
无侵入容器
在设计上，Spring的IoC容器是一个高度可扩展的无侵入容器。所谓无侵入，是指应用程序的组件无需实现Spring的特定接口，或者说，组件根本不知道自己在Spring的容器中运行。这种无侵入的设计有以下好处：
应用程序组件既可以在Spring的IoC容器中运行，也可以自己编写代码自行组装配置；
测试的时候并不依赖Spring容器，可单独进行测试，大大提高了开发效率。
2. 装配Bean组件
我们来看一个具体的用户注册登录的例子。整个工程的结构如下：
我们先编写一个MailService，用于在用户登录和注册成功后发送邮件通知：
public class MailService {
private ZoneId zoneId = ZoneId.systemDefault();
public void setZoneId(ZoneId zoneId) {
this.zoneId = zoneId;
}
public String getTime() {
return ZonedDateTime.now(this.zoneId).format(DateTimeFormatter.ISO_ZONED_DATE_TIME);
}
public void sendLoginMail(User user) {
System.err.println(String.format("Hi, %s! You are logged in at %s", user.getName(), getTime()));
}
public void sendRegistrationMail(User user) {
System.err.println(String.format("Welcome, %s!", user.getName()));
}
}
再编写一个UserService，实现用户注册和登录：
注意到UserService通过setMailService()注入了一个MailService。然后，我们需要编写一个特定的application.xml配置文件，告诉Spring的IoC容器应该如何创建并组装Bean：
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
注意观察上述配置文件，其中与XML Schema相关的部分格式是固定的，我们只关注两个
每个
在userServiceBean中，通过
Bean的顺序不重要，Spring根据依赖关系会自动正确初始化。
最后一步，我们需要创建一个Spring的IoC容器实例，然后加载配置文件，让Spring容器为我们创建并装配好配置文件中指定的所有Bean，这只需要一行代码：
ApplicationContextcontext=newClassPathXmlApplicationContext("application.xml");
接下来，我们就可以从Spring容器中“取出”装配好的Bean然后使用它：
// 获取Bean:
UserService userService = context.getBean(UserService.class);
// 正常调用:
User user = userService.login("[email protected]", "password");
创建Spring IoC容器
ClassPathXmlApplicationContext（常用）
我们从创建Spring容器的代码：
ApplicationContextcontext=newClassPathXmlApplicationContext("application.xml");
可以看到，Spring容器就是ApplicationContext，它是一个接口，有很多实现类，这里我们选择ClassPathXmlApplicationContext，表示它会自动从classpath中查找指定的XML配置文件。
从ApplicationContext中我们可以根据Bean的ID获取Bean，但更多的时候我们根据Bean的类型获取Bean的引用：
UserService userService = context.getBean(UserService.class);
其中，userService为实例化的一个类，得到的userService可以调用类中的方法。
BeanFactory
Spring还提供另一种IoC容器叫BeanFactory，使用方式和ApplicationContext
类似：
BeanFactoryfactory=newXmlBeanFactory(newClassPathResource("application.xml"));
MailService mailService = factory.getBean(MailService.class);
BeanFactory和ApplicationContext的区别在于，BeanFactory的实现是按需创建，即第一次获取Bean时才创建这个Bean，而ApplicationContext会一次性创建所有的Bean。实际上，ApplicationContext接口是从BeanFactory接口继承而来的，并且，ApplicationContext提供了一些额外的功能，包括国际化支持、事件和通知机制等。通常情况下，我们总是使用ApplicationContext，很少会考虑使用BeanFactory。
3. 使用Annotation进行简化配置
我们可以使用Annotation配置，可以完全不需要XML，让Spring自动扫描Bean并组装它们。
先删除XML配置文件，然后，给UserService和MailService添加几个注解。
首先，我们给MailService添加一个@Component注解：
@Component
public class MailService {
...
}
这个@Component注解就相当于定义了一个Bean，它有一个可选的名称，默认是mailService，即小写开头的类名。
然后，我们给UserService添加一个@Component注解和一个@Autowired注解：
@Component
public class UserService {
@Autowired
MailService mailService;
...
}
使用@Autowired就相当于把指定类型的Bean注入到指定的字段中。此外，还可以直接写在构造方法中：
最后，编写一个AppConfig类启动容器：
这里需要说明的是，
使用的实现类是AnnotationConfigApplicationContext，所以必须传入一个标注了@Configuration的类名。
AppConfig还标注了@ComponentScan，它告诉容器，自动搜索当前类所在的包以及子包，把所有标注为@Component的Bean自动创建出来，并根据@Autowired进行装配。
使用@ComponentScan非常方便，但是，我们也要特别注意包的层次结构。通常来说，启动配置AppConfig位于自定义的顶层包，其他Bean按类别放入子包。
4. 定制Bean组件
Scope（@Scope(“prototype”)）
Bean只需要一个实例：
对于Spring容器来说，当我们把一个Bean标记为@Component后，它就会自动为我们创建一个单例（Singleton），即容器初始化时创建Bean，容器关闭前销毁Bean。在容器运行期间，我们调用getBean(Class)获取到的Bean总是同一个实例。
需要不同实例：
还有一种Bean，我们每次调用getBean(Class)，容器都返回一个新的实例，这种Bean称为Prototype（原型），它的生命周期显然和Singleton不同。声明一个Prototype的Bean时，需要添加一个额外的@Scope注解：
@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) // @Scope("prototype")
public class MailSession {
...
}
注入List
有些时候，我们会有一系列接口相同，不同实现类的Bean。例如，注册用户时，我们要对email、password和name这3个变量进行验证。为了便于扩展，我们先定义验证接口：
public interface Validator {
//定义方法
void validate(String email, String password, String name);
}
然后，分别使用3个Validator对用户参数进行验证：
最后，我们通过一个Validators作为入口进行验证：
注意到Validators被注入了一个List
可选注入（无指定Bean）
默认情况下，当我们标记了一个@Autowired后，Spring如果没有找到对应类型的Bean，它会抛出NoSuchBeanDefinitionException异常。
可以给@Autowired增加一个required = false的参数：
@Component
public class MailService {
@Autowired(required = false)
ZoneId zoneId = ZoneId.systemDefault();
...
}
这个参数告诉Spring容器，如果找到一个类型为ZoneId的Bean，就注入，如果找不到，就忽略。
这种方式非常适合有定义就使用定义，没有就使用默认值的情况。
创建第三方Bean（不在包中的Bean）
如果一个Bean不在我们自己的package管理之内，例如ZoneId，如何创建它？
答案是我们自己在@Configuration类中编写一个Java方法创建并返回它，注意给方法标记一个@Bean注解：
@Configuration
@ComponentScan
public class AppConfig {
// 创建一个Bean:
@Bean
ZoneId createZoneId() {
return ZoneId.of("Z");
}
}
Spring对标记为@Bean的方法只调用一次，因此返回的Bean仍然是单例。（多次则@Bean(prototype)）
初始化和销毁
有些时候，一个Bean在注入必要的依赖后，需要进行初始化（监听消息等）。在容器关闭时，有时候还需要清理资源（关闭连接池等）。
在此之前，需要引入JSR-250定义的Annotation：
在Bean的初始化和清理方法上标记@PostConstruct和@PreDestroy：
Spring容器会对上述Bean做如下初始化流程：
调用构造方法创建MailService实例；
根据@Autowired进行注入；
调用标记有@PostConstruct的init()方法进行初始化。
而销毁时，容器会首先调用标记有@PreDestroy的shutdown()方法。
Spring只根据Annotation查找无参数方法，对方法名不作要求。
使用别名
当我们需要创建多个同类型的Bean时，我们就会用到别名：
可以用@Bean("name")指定别名，也可以用@Bean+@Qualifier("name")指定别名。
指定了别名后，注入时就需要指定Bean的名称，不然会报错：
@Component
public class MailService {
@Autowired(required = false)
@Qualifier("z") // 指定注入名称为"z"的ZoneId
ZoneId zoneId = ZoneId.systemDefault();
...
}
或者指定默认Bean，当注入时没有指定Bean的名字，则默认注入标记有@Primary的Bean：
使用FactoryBean（工厂模式）
用工厂模式创建Bean需要实现
FactoryBean接口。我们观察下面的代码：
当一个Bean实现了FactoryBean接口后，Spring会先实例化这个工厂，然后调用getObject()创建真正的Bean。getObjectType()可以指定创建的Bean的类型，因为指定类型不一定与实际类型一致，可以是接口或抽象类。
因此，如果定义了一个FactoryBean，要注意Spring创建的Bean实际上是这个FactoryBean的getObject()方法返回的Bean。为了和普通Bean区分，我们通常都以XxxFactoryBean命名。
5. 使用Resource读取文件
在Java程序中，我们经常会读取配置文件、资源文件等。使用Spring容器时，我们也可以把“文件”注入进来，方便程序读取。
上图是工程的结构，我们需要读取logo.txt文件，通常情况下，我们需要写很多繁琐的代码，主要是为了定位文件，打开InputStream。Spring则提供了一个org.springframework.core.io.Resource，可以直接注入：
也可以直接指定文件的路径，例如：
@Value("file:/path/to/logo.txt")
private Resource resource;
6. 注入配置（读取配置文件）
@PropertySource注入配置
除了像Resource读取文件那样，Spring容器提供了一个更简单的@PropertySource
来自动读取配置文件。我们只需要在@Configuration配置类上再添加一个注解：
Spring容器看到@PropertySource("app.properties")注解后，自动读取这个配置文件，然后，我们使用@Value正常注入：
@Value("${app.zone:Z}")
String zoneId;
注意注入的字符串语法，它的格式如下：
"${app.zone}"表示读取key为app.zone的value，如果key不存在，
启动将报错；
"${app.zone:Z}"表示读取key为app.zone的value，但如果key不存在，就使用默认值Z
还可以把注入的注解写到方法参数中：
@BeanZoneId
createZoneId(@Value("${app.zone:Z}") String zoneId) {
return ZoneId.of(zoneId);
}
Bean中标记，需要注入的地方再标记
另一种注入配置的方式是先通过一个简单的JavaBean持有所有的配置，例如，一个
SmtpConfig：
然后，在需要读取的地方，使用#{smtpConfig.host}注入：
"#{smtpConfig.host}"的意思是，从名称为smtpConfig的Bean读取host属性，即调用getHost()方法。
使用一个独立的JavaBean持有所有属性，然后在其他Bean中以#{bean.property}注入的好处是，多个Bean都可以引用同一个Bean的某个属性。例如，如果SmtpConfig决定从数据库中读取相关配置项，那么MailService注入的@Value("#{smtpConfig.host}")仍然可以不修改正常运行。
7. 使用条件装配
定义不同环境
Spring为应用程序准备了Profile这一概念，用来表示不同的环境。例如，我们分别定义开发、测试和生产这3个环境：
native
test
production
创建某个Bean时，Spring容器可以根据注解@Profile来决定是否创建。例如，以下配置：
如果当前的Profile设置为test，则Spring容器会调用createZoneIdForTest()创建ZoneId，否则，调用createZoneId()创建ZoneId。注意到@Profile("!test")表示非test环境。
在运行程序时，加上JVM参数-Dspring.profiles.active=test就可以指定以test环境启动。
实际上，Spring允许指定多个Profile，例如：
-Dspring.profiles.active=test,master
可以表示test环境，并使用master分支代码。
要满足多个Profile条件，可以这样写：
@Bean
@Profile({ "test", "master" }) // 同时满足test和master
ZoneId createZoneId() {
...
}
使用Conditional（条件注解）决定是否创建Bean
除了根据@Profile条件来决定是否创建某个Bean外，Spring还可以根据
@Conditional决定是否创建某个Bean。
例如，我们对SmtpMailService添加如下注解：
@Component
@Conditional(OnSmtpEnvCondition.class)
public class SmtpMailService implements MailService {
...
}
它的意思是，如果满足OnSmtpEnvCondition的条件，才会创建SmtpMailService这个Bean。
public class OnSmtpEnvCondition implements Condition {
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
return "true".equalsIgnoreCase(System.getenv("smtp"));
}
}
Spring只提供了@Conditional注解，具体判断逻辑还需要我们自己实现。
好啦，今天的文章就到这里，希望能帮助到屏幕前迷茫的你们！