全注解下的Spring IoC

1.什么是Bean?

在Spring中把每一个需要管理的对象称为Spring Bean（简称Bean）

2.什么是IoC容器？

Spring IoC容器是一个管理Bean的容器，它要求所有的IoC容器都需要实现接口BeanFactory。

下面是BeanFactory接口源码：

package org.springframework.beans.factory;

public interface BeanFactory {

    /**
     * 用来引用一个实例，或把它和工厂产生的Bean区分开，就是说，如果一个FactoryBean的名字为a，那么，&a会得到那个Factory
     */
    String FACTORY_BEAN_PREFIX = "&";

    /*
     * 四个不同形式的getBean方法，获取实例
     */
    Object getBean(String name) throws BeansException;

    <T> T getBean(String name, Class<T> requiredType) throws BeansException;

    <T> T getBean(Class<T> requiredType) throws BeansException;

    Object getBean(String name, Object... args) throws BeansException;

    boolean containsBean(String name); // 是否存在

    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;// 是否为单实例

    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;// 是否为原型（多实例）

    boolean isTypeMatch(String name, Class<?> targetType)
            throws NoSuchBeanDefinitionException;// 名称、类型是否匹配

    Class<?> getType(String name) throws NoSuchBeanDefinitionException; // 获取类型

    String[] getAliases(String name);// 根据实例的名字获取实例的别名

}

默认情况下，Bean都是以单例形式存在，即使用getBean方法返回的都是同一对象。

3.如何从IoC容器中取出Bean

通过上面的源码可以看到，getBean方法有按类型（type）获取Bean的，也有按名称（name）获取Bean的，这对于后面介绍的Spring依赖注入很重要。

4.ApplicationContext和BeanFactory的关系

由于BeanFactory的功能不够强大，Spring在BeanFactory的基础上，设计了一个ApplicationContext接口，是BeanFactory的子接口，他们的关系如下（图片来源于网络）：

第3章全注解下的Spring IoC全注解下的Spring IoC

在Spring Boot中，主要通过注解方式装配Bean到Spring IoC容器中（也支持XML）.

5.装配Bean注入IoC容器(通过两个实例理解)

（1）@Bean

首先定义一个Java简单对象，文件User.java，代码如下：

package com.springboot.chapter3.pojo;

import java.util.LongSummaryStatistics;

/**
 * Created by lizeyang on 2019/5/7.
 */
public class User {
    private Long id;
    private String userName;
    private String note;

    public Long getId() {
        return id;
    }

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

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

然后再定义一个Java配置文件AppConfig.java，代码如下：

package com.springboot.chapter3.config;

import com.springboot.chapter3.pojo.User;
import org.springframework.boot.autoconfigure.security.SecurityProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Created by lizeyang on 2019/5/7.
 */
@Configuration
public class AppConfig {
    @Bean(name="user")
    public User initUser(){
        User user = new User();
        user.setId(1L);
        user.setUserName("user_name_1");
        user.setNote("note_1");
        return user;
    }
}

其中@Configuration代表这是一个Java配置文件，Spring容器会根据它来生成IoC容器装配Bean。@Bean代表将initUser方法返回的POJO返回到IoC容器中，属性name定义这个Bean的名称，若不配置，方法名即为Bean名称。

最后，使用AnnotationConfigApplicationContext构建IoC容器，代码如下：

package com.springboot.chapter3.config;

import com.springboot.chapter3.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * Created by lizeyang on 2019/5/7.
 */
public class IoCTest {
    public static void main(String[] args){
        ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
        User user = ctx.getBean(User.class);
        System.out.println(user.getId());
    }
}

运行IoCTest结果如下：

第3章全注解下的Spring IoC全注解下的Spring IoC

显然，配置在配置文件中名称为user的Bean已经装配到IoC容器中，并且可以通过getBean方法获取对应的Bean，并将Bean的属性输出出来。

（2）@ComponentScan

除了@Bean，还可以使用@Component和@ComponentScan，@Component是标明哪个类被扫描进入Spring IoC容器，@ComponentScan是标明采用何种策略扫描装配Bean。

首先，在包com.springboot.chapter3.config内新建UserCpoy.java文件，代码如下：

package com.springboot.chapter3.config;

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

/**
 * Created by lizeyang on 2019/5/7.
 */
@Component("UserCopy")
public class UserCopy {
    @Value("1")
    private Long id;

    @Value("user_name_1")
    private String userName;

    @Value("note_1")
    private String note;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public Long getId() {
        return id;
    }

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

修改配置文件为：AppConfigCopy，代码为：

package com.springboot.chapter3.config;

import com.springboot.chapter3.pojo.User;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

/**
 * Created by lizeyang on 2019/5/7.
 */
@Configuration
@ComponentScan
public class AppConfigCopy {
//    public User initUser(){
//        User user = new User();
//        user.setId(1L);
//        user.setUserName("user_name_1");
//        user.setNote("note_1");
//        return user;
//    }
}

运行IoCTest，结果与上面相同。

6.什么是依赖注入？

依赖注入就是Bean之间的依赖，最常用的是@Autoeired注解，它会根据属性的类型(type)找到对应的Bean进行注入（还记得BeanFactory里面getBean方法的两种方式吗？）

另外。可以通过@Primary修改多个不同类型的Bean的优先权，或者将@Autowired和@Qualifier结合使用，通过类型和名称一起找到Bean。

7.Spring IoC初始化和销毁Bean过程——Bean生命周期

分为Bean定义、Bean初始化、Bean生存期和Bean的销毁4个部分。

下图为Spring Bean的初始化流程：

第3章全注解下的Spring IoC全注解下的Spring IoC

下面是Spring Bean的生命周期：

第3章全注解下的Spring IoC全注解下的Spring IoC

8.属性文件使用——application.properties

在Spring Boot中，我们一般先在Maven配置文件中加载依赖，Spring Boot将创建读取属性文件的上下文。如：

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

有了依赖，就可以直接使用application.properties文件，通过其机制读取到上下文中，之后便可引用它。如：

spring.datasource.url=jdbc:mysql://localhost:3306/toutiao?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=nowcoder
mybatis.config-location=classpath:mybatis-config.xml
#logging.level.root=DEBUG

引用有两种方法，一种是Spring表达式，如通过@Value注解，使用${...}占位符读取配置在属性文件中的内容，如：

@Component
public class DataBaseProperties{
    @Value("${database.drivename}")
    private String driveName = null;
}

另一种方法就是使用@ConfigurationProperties注解，如：

@Component
@ConfigurationProperties("database")

public class DataBaseProperties{
    ......
}

9.单例（isSingleton）和原型(isPrototype)的区别

我们通过一段代码来进行比较两者区别：

@Component
//@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class ScopeBean{
    ...
}

//测试作用域
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
ScopeBean scopeBean1 = ctx.getBean(ScopeBean.class);
ScopeBean scopeBean2 = ctx.getBean(ScopeBean.class);
System.out.println(scopeBean1 == scopeBean2);

在第二行代码注释之后，测试结果为true，说明scopeBean1和scopeBean2变量都指向同一个实例，即为单例。

若将注释消去，则设置Bean的作用域为prototype，让IoC容器每次获取Bean时，都新建一个Bean的实例返回给调用者。

10.XML配置Bean

尽管Sping Boot建议使用注解和扫描配置Bean，但也不拒绝XML配置Bean.

通过一个例子来了解XML配置Bean：

先新建一个松鼠实现类，代码如下：

package com.springboot.other.pojo;

import com.springboot.chapter3.pojo.definition.Animal;


public class Squirrel implements Animal {

	@Override
	public void use() {
		System.out.println("松鼠可以采集松果");
	}

}

这个文件所在的包不在@ComponentScan定义的扫描包com.springboot.chapter3.*之内，也没有标注@Component，所以不会被扫描机制所装配，我们使用XML文件来装配，代码如下：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
       <bean id="squirrel" class="com.springboot.other.pojo.Squirrel"/>
</beans>

最后，装配XML定义的Bean，代码如下：

@Configuration
@ComponentScan(basePackages = "com.springboot.chapter3.*")
@ImportResource(value = {"classpath:spring-other.xml"})
public class AppConfig {
    ......
}

这样就可以引入对应的XML，进而将XML定义的Bean装配到IoC容器中。

11.使用Spring EL(了解即可)

Spring EL是一种表达式语言，通过Spring EL可以拥有更强大的运算规则来装配Bean，最常用的是读取属性文件的值，如：

@Value("#{3.14}")
private float pi;

@Value("#{1+2}")
private int run;

总结

Spring Boot关于IoC的部分基本就是这些，本节代码已上传github:

https://github.com/lizeyang18/SpringBoot-2.x/tree/master/Chapter3

第3章全注解下的Spring IoC全注解下的Spring IoC

全注解下的Spring IoC

1.什么是Bean?

2.什么是IoC容器？

3.如何从IoC容器中取出Bean

4.ApplicationContext和BeanFactory的关系

5.装配Bean注入IoC容器(通过两个实例理解)

（1）@Bean

（2）@ComponentScan

6.什么是依赖注入？

7.Spring IoC初始化和销毁Bean过程——Bean生命周期

8.属性文件使用——application.properties

9.单例（isSingleton）和原型(isPrototype)的区别

10.XML配置Bean

11.使用Spring EL(了解即可)

总结

学习永不止步，继续加油~

继续阅读

openfans领域模型驱动的尝试

@Value的几种常用用法

Android的前后端交互框架搭建（okhhtp+springboot+mysql完整版）

start to use skywalkingInstall JDK8Install ESInstall skywalkingRun Springboot JAR

关于Springboot中JSCH使用说明1. JSCH简介2. JSCH依赖3. 使用方法4. 使用连接池

路径错误Maven：Non-resolvable parent POM: Failure to find错误

jsch连接服务器执行命令返回的数据中文乱码问题问题分析解决

springboot项目时间不一致解决方案一、springboot项目时间不一致解决方案

spring mvc 页面传递数组后台接收方式spring mvc 页面传递数组后台接收方式

Swagger-UI的使用一、添加依赖二、创建配置类三、注解

将swagger-ui中的接口导入postman

聊一聊Swagger-UI的那些事情软件简介Swagger 原生Bootstrap-ui Bootstrap的UIKnife4j Bootstrap的升级版的UI

springboot使用 swagger-ui 2.10.5 有关版本更新带来的问题

微服务-性能压测\缓存redis和分布式锁redisson和SpringCache

java 8 Lamda 求 List 中 Bigdecimal类型的各种值求最大值求最小值求和求平均值

(SpringBoot)日志种类：log、monitor、access、out、gc、backup

第3章 全注解下的Spring IoC全注解下的Spring IoC

全注解下的Spring IoC

1.什么是Bean?

2.什么是IoC容器？

3.如何从IoC容器中取出Bean

4.ApplicationContext和BeanFactory的关系

5.装配Bean注入IoC容器(通过两个实例理解)

（1）@Bean

（2）@ComponentScan

6.什么是依赖注入？

7.Spring IoC初始化和销毁Bean过程——Bean生命周期

8.属性文件使用——application.properties

9.单例（isSingleton）和原型(isPrototype)的区别

10.XML配置Bean

11.使用Spring EL(了解即可)

总结

学习永不止步，继续加油~

继续阅读

第3章全注解下的Spring IoC全注解下的Spring IoC