Spring学习笔记（1）----Spring IOC学习和理解

时间  2020-07-06
标签 spring 学习 笔记 ioc 理解 栏目 Spring 繁體版
原文   原文链接

1. 基本思想和概念

1.1 Spring IOC思想

Spring IOC（Inversion of Control，控制反转）是Spring的一个核心思想，其包括两层含义：html

  • 控制：控制是指当前对象对内部依赖对象的控制权，好比建立依赖对象。
  • 反转：这种控制权不禁当前对象来管理，由第三方（好比容器）来管理。（反转也能够理解为获取依赖对象的方式从主动变成了被动）

在Spring中，控制反转也能够简单地理解为将对象的建立和管理交由IOC容器来完成。java

1.2 依赖注入（Dependency Injection）

IOC将依赖对象的控制权转移到外部，但当前对象仍是须要依赖对象的，这时候就须要使用依赖注入将所须要的依赖对象从外部注入进来。spring

1.3 控制反转与依赖注入的关系

控制反转是一种思想，而依赖注入是一种实现方式。segmentfault

  • 有些文章有提到，实现控制反转的方式还有依赖查找。

1.4 Spring IOC的优势

为何须要使用Spring IOC？从IOC思想来看，主要有两大优势：数组

  • 资源集中管理，实现资源可配置和易管理；
  • 经过IOC实现当前对象和依赖对象之间的松耦合；

从Spring IOC的实际实现来看，还有以下好处：bash

  • 享受单例的好处，效率高，节约空间；
  • 便于单元测试，方便切换mock组件；
  • 便于进行AOP操做；

1.4.1 Spring IOC实现松耦合理解

没有IOC的状况下，使用依赖的对象须要手动new一个对象出来，根据构造器是否须要参数，能够分为有参对象和无参对象。而Spring只须要在xml文件中集中配置一次，或者使用注解就能够实现依赖注入，不须要手动new对象出来。app

接下来考虑几种须要修改具体对象实现的状况下代码重构的成本，来理解Spring IOC如何实现松耦合。工具

（1）无参对象，须要修改类名

好比须要将类名从Message修改成News，那么此时能够借助开发工具的重构功能实现代码重构。
重构难度：1星。post

（2）无参对象，须要修改对象类型

好比须要将对象类型名从Student修改成Teacher，那么此时能够借助查找替换功能实现代码重构。 无重写方法状况下，重构难度：2星； 有重写方法状况下，重构难度：3星；单元测试

（3）有参对象，须要修改参数；

好比须要在建立Student对象时，增长年龄参数，此时借助查找功能也须要一个个手动修改代码，增长参数。
重构难度：5星。

（4）Spring IOC重构

若是使用Spring IOC，即使对难度最大的第三种状况，也只须要在xml文件中修改下注入的参数，或者在对应对象中增长一个属性，并使用注解自动注入便可。
重构难度：1星。

2. Spring IOC容器简介

IOC容器是Spring提供的一个工厂，用于管理全部的bean、以及bean之间的关系。

2.1 Spring IOC容器原理

  • IOC容器底层原理是Java反射机制，经过反射机制获取类的全部信息（属性、类名等）；
  • IOC容器再经过读取xml文件、或者注解来获取bean之间依赖关系。

2.2 常见IOC容器

Spring中主要提供两类IOC容器，分别是BeanFactory和ApplicationContext。

  • BeanFactory: 最基础的IOC容器，提供完整的IOC服务支持。
  • ApplicationContext: ApplicationContext是在 BeanFactory的基础之上构建的，是相对比较高级的容器实现。

二者间继承关系以下图，可见ApplicationContext间接继承自BeanFactory。

2.2.1 BeanFactory

BeanFactory是Spring提供的最基础的IOC容器，用于帮助完成bean的注册和bean之间关系的绑定。
特色：

  • 默认采用延加载策略。当容器中bean被访问时，才进行bean的初始化和依赖注入工做。

2.2.1.1 实现类

BeanFactory最基础的实现类是DefaultListableBeanFactory。
旧版本中BeanFactory最多见实现类是XmlBeanFactory（现已被废弃），新版中使用XmlBeanDefinitionReader + DefaultListableBeanFactory替代XmlBeanFactory。

2.2.1.2 代码示例

（1）创建一个工程，引入响应jar包

出于方便，可直接创建了一个SpringBoot工程。

（2）创建xml文件，复制基本结构
<?xml version="1.0" encoding="UTF-8"?>
<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-3.0.xsd">
    
</beans>
复制代码
（3）建立对象类

这里使用@Data注解省略了getter和setter方法。

@Data
public class User {
    private Integer age;
    private Nation nation;

    public User() {
    }
    public User(Integer age) {
        this.age = age;
    }
    public User(Nation nation) {
        this.nation = nation;
    }
}
复制代码
（4）在配置文件中注册一个bean
<bean id="user" class="com.example.springdemo.xml.model.User">
    <constructor-arg name="age" type="java.lang.Integer" value="26"></constructor-arg>
</bean>
复制代码
（5）实例化容器、加载配置文件、获取bean
public static void main(String[] args) {
    // 1. XmlBeanFactory方式，已废弃
    // XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("application.xml"));

    // 2. XmlBeanDefinitionReader + DefaultListableBeanFactory 替代XmlBeanFactory
    Resource resource = new ClassPathResource("application.xml");
    BeanFactory factory = new DefaultListableBeanFactory();
    BeanDefinitionReader bdr = new XmlBeanDefinitionReader((BeanDefinitionRegistry) factory);
    bdr.loadBeanDefinitions(resource);
    // 根据bean名从容器中获取bean
    User user1 = (User) factory.getBean("user");
    System.out.println(user1.getAge());
}
复制代码

2.2.2 ApplicationContext

ApplicationContext是在BeanFactory的基础上构建的，是相对比较高级的容器实现，除了拥有 BeanFactory的全部支持，ApplicationContext还提供了其余高级特性，好比：

  • 统一资源加载策略
  • 国际化信息支持
  • 容器内部事件发布机制

2.2.2.1 实现类

ApplicationContext常见实习类有：FileSystemXmlApplicationContext、ClassPathXmlApplicationContext和XmlWebApplicationContext。

2.2.2.2 代码示例

仍然使用BeanFactory示例中的配置文件，同时使用ClassPathXmlApplicationContext来读取xml文件。

// 3. ApplicationContext拥有比BeanFactory更高级的特性
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
User user3 = (User) applicationContext.getBean("user");
System.out.println(user3.getAge());
复制代码

3. Spring IOC容器装配Bean详解

3.1 依赖注入方式

依赖注入方式主要包括：

  • 构造器注入
  • 属性注入（setter方法注入）

其中经常使用的两种方式是构造器注入和属性注入。虽然官方文档建议能用构造器注入就用构造器注入，由于这样可使得依赖关系明确，而且若是缺乏依赖的话在初始化阶段就能够发现问题。但属性注入更加灵活，而且构造器注入方式没法解决循环依赖问题，因此通常使用属性注入，强制依赖建议使用构造器方式注入。

3.1.1 构造器注入

基于构造器的依赖注入是指，在bean的构造器中指明依赖的bean，并在初始化时完成注入。

代码示例

（1）bean类

User类见2.2.1.2中，存在以下构造器：

public User(Integer age) {
    this.age = age;
}
复制代码
（2）在xml中注册bean，并经过构造器方式进行依赖注入
<!-- 构造器方式注入 -->
<bean id="user" class="com.example.springdemo.xml.model.User">
    <constructor-arg name="age" type="java.lang.Integer" value="26"></constructor-arg>
</bean>
复制代码

3.1.2 属性注入

基于属性的依赖注入是指，容器经过无参构造器初始化bean，再经过调用setter方法来完成注入。

  • 不必定是无参构造器，只要后续经过setter方法进行注入就行。
（1）bean类

User类如上，有属性age（经过@Data注解省略了getter/setter方法）：

private Integer age;
复制代码

（2）注册bean，并经过属性方式进行依赖注入

<!-- 属性注入 -->
<bean id="user2" class="com.example.springdemo.xml.model.User">
    <property name="age" value="27"></property>
</bean>
复制代码

（3）获取bean，并输出其依赖

// user使用了构造器注入
User user1 = (User) factory.getBean("user");
System.out.println("DI by constructor：" + user1.getAge());
// user2使用了属性注入
User user2 = (User) factory.getBean("user2");
System.out.println("DI by setter：" + user2.getAge());
复制代码

输出：

3.2 自动装配

3.2.1 手动注入依赖bean

在3.1小节中，User bean注入了int型的age属性，一样能够注入其它由IOC容器管理的bean。

（1）bean类

User类还存在以下构造器，表示User bean依赖Nation bean。

public User(Nation nation) {
    this.nation = nation;
}
复制代码

Nation类：

public class Nation {
    public String name;
    public Nation(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
复制代码

（2）注册bean，并声明依赖关系

注册Nation bean，同时注册User bean，并使用构造器方式对User bean注入Nation bean。

<bean id="nation" class="com.example.springdemo.xml.model.Nation">
    <constructor-arg name="name" type="java.lang.String" value="China"></constructor-arg>
</bean>

<!-- 手动注入依赖bean -->
<bean id="user3" class="com.example.springdemo.xml.model.User">
    <constructor-arg name="nation" type="com.example.springdemo.xml.model.Nation" ref="nation"></constructor-arg>
</bean>
复制代码

（3）获取bean，并输出其依赖bean的属性

// 注入IOC容器管理的bean，user注入时须要nation。
// 这时候也能明显体现Spring Ioc解耦的优势，若是不使用依赖注入，将对象的建立交由bean来作的话，代码以下。
// 若是须要修改传入参数，项目中全部地方都须要修改
Nation nation = new Nation("China");
User user4 = new User(nation);
System.out.println("Name of nation in user3 by code: " + user4.getNation().getName());
// 而使用依赖注入的话，只须要在xml中一个地方集中配置管理，在配置文件中注入取值或者内部bean，而不须要每一个建立对象的地方都要修改
User user5 = (User) factory.getBean("user3");
System.out.println("Name of nation in user3 by IOC: " + user5.getNation().getName());
复制代码

输出：

3.2.2 自动装配

在实际项目中，通常对于Dao、Service都须要单例，不会建立过多的bean，那么不少时候这些bean并不存在name、type的冲突，这时候是否是能够根据特定的规则，来简化bean的装配。
Spring IOC容器还提供了自动装配，能够根据bean的type、name进行自动装配，而不须要显示地声明bean间依赖关系。

（1）xml中声明自动装配

<!-- 自动装配bean，这里是byType方式。自动装配时会将知足条件的bean注入到构造器和setter方法中 -->
<!-- 自动装配缺点：（1）不适用构造器重写的状况；（2）不能装配基本类型和字符串 -->
<bean id="user4" class="com.example.springdemo.xml.model.User" autowire="byType">
    <constructor-arg name="age" type="java.lang.Integer" value="28"></constructor-arg>
</bean>
复制代码

（2）获取bean，并输出其依赖bean

// 自动装配bean
User user6 = (User) factory.getBean("user4");
System.out.println("自动装配：" + user6.getAge());
System.out.println("自动装配：" + user6.getNation().getName());
复制代码

输出：

3.3 读取依赖关系方式

Spring IOC容器读取依赖关系方式有：

  • （1）xml配置文件方式
  • （2）注解方式
  • （3）JavaConfig：属于注解方式中特殊方式，在一个java类集中使用注解来注册bean、声明bean间依赖关系，能够理解为将一个的xml配置文件变成了一个Java配置类，而且注解形式来声明。

相比较而言，xml配置文件方式拥有集中配置的优势，而注解方式则拥有简化配置的优势。

3.3.1 xml配置文件

Spring IOC容器能够经过加载xml配置文件，来读取依赖关系。

  • 3.2示例的代码都是经过此种方式来读取bean间依赖关系。

3.3.2 注解

因为xml配置文件拥有繁杂、不易配置的缺点，Spring IOC容器还同时支持注解来简化配置。
使用注解来读取依赖关系的步骤以下：

（1）声明注解

在bean类上使用注解@Component声明bean，使用注解@Autowired来声明依赖关系：

@Component
@Data
public class User {
    private Integer age;
    
    @Autowired
    private Nation nation;
}
复制代码

（2）实例化容器、设置要扫描注解类

建立ApplicationContext类型的IOC容器（BeanFactory实测不支持），并设置要扫描注解的包路径。

// 能够传入要扫描的包路径动态数组，也能够传入Class动态数组
ApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.example.springdemo.annation");

User user1 = (User) applicationContext.getBean("user");
System.out.println(user1.getNation().getName());
复制代码

3.3.3 xml配置文件和注解混用

Spring IOC容器其实还支持xml配置文件和注解混用的方式来读取bean间依赖关系。

（1）在User类的nation的属性上添加@Autowired

@Autowired
private Nation nation;
复制代码

（2）配置文件中注册bean

使用构造器方式注入age属性，但没有注入nation字段

<!-- 注解与xml混用方式，这里并无注入nation，也没有使用自动装配 -->
<bean id="user5" class="com.example.springdemo.xml.model.User">
    <constructor-arg name="age" type="java.lang.Integer" value="30"></constructor-arg>
</bean>
复制代码

（3）获取bean

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
// xml与注解混用，经过@Autowired注入nation bean（实际测试BeanFactory不支持注解，须要使用ApplicationContext）
User user7 = (User) applicationContext.getBean("user5");
System.out.println(user7.getAge());
System.out.println(user7.getNation().getName());
复制代码

从输出能够发现age和nation属性都被注入了。

3.4 注解

在3.3.2中介绍了注解的简单使用，因为注解已经成为如今主流的使用方式，接下来详细介绍些经常使用注解知识。

3.4.1 bean注册

@Bean、@Component等注解用于将对象注册为bean，交由Spring容器管理。

  • @Component注解在类上使用，将类的定义与bean的声明绑定，@Bean则将二者分离。通常@Component更适合声明service、dao等单例对象，而@Bean更适合用于在不一样场景下建立不一样对象的状况。
  • @Controller、@Service和@Repository属于@Component的一种，通常分别用于controller层、service层和持久化层。我的理解@Service注解和@Component没有什么区别。
  • @Bean注解使用在方法上。

（1）@Bean

  • 可以使用@Bean注解注册同一类的多个bean，该注解使用在方法上。
  • 可在被@Componet、@Configuration注解声明的类里面使用声明里面使用；
  • 默认bean名为首字母小写的方法名，也可使用name字段设置bean名。
@Bean
// @Primary表示默认bean，当有多个相同类型的bean时，可使用@Primary来表示默认bean，其它地方注入依赖时就不须要都指明具体bean名。
@Primary
public Nation nation1() {
    return new Nation("China");
}

@Bean
public Nation nation2() {
    return new Nation("England");
}

// 使用name属性为bean命名
@Bean(name = "nation3")
public Nation nation() {
    return new Nation("America");
}
复制代码

（2）@Primary

当有多个相同类型的bean时，可使用@Primary来表示默认bean，其它地方注入默认bean时就不须要指明具体bean名。

（3）@Value和@ConfigurationProperties

可使用@Value注解来注入外部属性，而@ConfigurationProperties则可用来注入一整个对象的全部属性，或者说批量注入外部属性。

@Configuration
@PropertySource("classpath:application.properties")
public class JavaConfiguration {}
复制代码
@Bean
// 使用@Value来注入外部属性，须要使用@PropertySource引入资源文件。还可使用@ConfigurationProperties来批量注入外部属性
public Nation nation4(@Value("${nation4.name:#{null}}") String nation4name) {
    return new Nation(nation4name);
}
复制代码

3.4.2 bean注入

@Autowired和@Required用来注入依赖的bean。

（1）@Autowired

  • @Autowired注解能够在字段上使用，也能够在setter方法上使用，同时能够在构造器上使用。
  • @Autowired默认采用了自动装配，且优先根据类型自动装配，同类型则优先注入primary bean，而后再依据bean名（与属性同名）进行注入。
  • @Autowired还能够结合@Qualifier来指定要注入的bean名。例如：@Qualifier("nation2")。

（2）@Required

@Required注解也能够用来注入依赖，但已经被废弃。

（3）@Resource

Spring同时支持JSR-250的注解，一样可使用@Resource来注入依赖（字段或者setter方法上），并使用name字段来指定bean名。例如：@Resource(name = "nation2")。

（4）@Inject

Spring3.0还支持JSR-330注解，可使用@Inject来注入依赖。

3.4.3 Java config

@Configuration注解代表该类是一个Java配置类，用于声明bean，在该类中可使用@Bean注解来声明bean。通常状况下会将同一功能或用途的bean在一个配置累中声明。

3.5 Bean做用域（scope）

Spring IOC中Bean有多种不一样做用域，主要有：

  • singleton
  • prototype

接下来主要介绍下singleton和prototype做用域。

3.5.1 singleton模式

singleton模式（单例模式）是默认模式，该模式的bean有如下特色：

  • 容器中该bean只存在一个实例；
  • 实例存活时间：从容器启动，到第一次因请求而实例化，只要容器不销毁或退出，该实例一直存在。
代码示例

（1）注册bean 注册一个bean名为nation1的单例bean。

@Bean
public Nation nation1() {
    return new Nation("China");
}
复制代码

（2）从容器获取bean 两次从容器中获取同一个bean，是同一对象地址相同。

// 建立的nation1和nation2对象是相同bean
Nation nation1 = (Nation) applicationContext.getBean("nation1");
Nation nation2 = (Nation) applicationContext.getBean("nation1");
System.out.println("nation1 == nation2: " + (nation1 == nation2));
复制代码

输出：

3.5.2 prototype模式

prototype模式（原型模式、多例模式）的bean有如下特色：

  • 每次从容器中请求bean都会从新生成一个实例；
代码示例

（1）注册bean 注册一个名为nation7的多例bean。

@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public Nation nation7() {
    return new Nation();
}
复制代码

（2）从容器获取bean 两次从容器获取同一个bean，是不一样的对象，地址不一样。

// nation3和nation4是不一样bean。
// 此处须要注意，若是bean类上使用了lombok注解，不要被输出所迷惑，由于lombok重写了toString()，使得二者看起来像是一个对象，实际应该比较对象地址
Nation nation3 = (Nation) applicationContext.getBean("nation7");
Nation nation4 = (Nation) applicationContext.getBean("nation7");
System.out.println("nation3 == nation4: " + (nation3 == nation4));
System.out.println("nation3:" + nation3);
System.out.println("nation4:" + nation4);
复制代码

输出：

3.6 循环依赖

未完待续。。。。。

小结

Spring IOC能够说是Spring全家桶的基石，AOP等都依赖IOC的实现，要理解学习Spring应该先掌握Spring IOC的知识。
本文先是简单介绍了Spring IOC的思想和一些基本概念，而后针对Spring IOC容器实现依赖注入相关的知识点，而且分别给出了xml形式和注解形式依赖注入代码实现。

参考网址

https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/index.html
https://juejin.im/post/5bf51d4c5188256d9832b0d3
https://segmentfault.com/a/1190000013700859
https://segmentfault.com/a/1190000014979704
https://juejin.im/post/5b399eb1e51d4553156c0525
复制代码
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程