Spring IOC:依赖注入和bean的生命周期

一、Spring框架的介绍

1. Spring框架的概述

Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。

Spring是于2003 年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE.

Development and Design中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 JavaEE 应用程序开发提供集成的框架。

Spring的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

IOC:控制反转，将创建对象的过程交给spring进行管理.

AOP:面向切面，在不修改源代码的情况之下进行代码功能的增强。

2. Spring框架的优点

方便解耦，简化开发，Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理，这也是IOC的作用。

AOP编程的支持，Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。

声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程。

方便程序的测试，Spring对Junit4支持，可以通过注解方便的测试Spring程序。

方便集成各种优秀框架，Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、Hibernate、MyBatis等）的直接支持。

降低JavaEE API的使用难度，Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

二、创建Spring项目

创建maven工程，导入坐标依赖

XML 复制代码

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

编写实体类

java 复制代码

package com.qcby;

import org.springframework.stereotype.Controller;

@Controller//("us")
public class User {

    private String name;
    private int age;
    public void run(){
        System.out.println("running...");
    }
}

编写Spring核心的配置文件，在resources目录下创建applicationContext.xml的配置文件，名称是可以任意的，但是一般都会使用默认名称。

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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--    <bean id="user" class="com.qcby.User"/>-->
<!--    <bean id="dog" class="com.qcby.Dog"/>-->

<!--    &lt;!&ndash;开启注解扫描&ndash;&gt;-->
<!--    <context:component-scan base-package="com.qcby"/>-->
    <bean id="users" class="com.qcby.Users"/>
</beans>

编写测试方法。

java 复制代码

import com.qcby.Dog;
import com.qcby.User;
import com.qcby.Users;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserTest {

    @Test
    public void test1() {
        User user = new User();//人为创建对象
        user.run();
    }

    @Test
    public void test2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User) context.getBean("user");
        user.run();
    }
    @Test
    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Dog dog = (Dog) context.getBean("dog");
        dog.run();
    }
    @Test
    public void test4() {
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User) context.getBean("user");
        user.run();

//        Users users = (Users) context.getBean("users");
//        users.run();

        Dog dog = (Dog) context.getBean("dog");
        dog.run();
    }

    @Test
    public void test5() {
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Users users = (Users) context.getBean("users");
        users.setAge(18);
        users.setName("小王");
        System.out.println(users);
    }
}

三、Spring IOC容器

1. 什么是IOC思想

IOC -- Inverse of Control，控制反转，将对象的创建权力反转给Spring框架！

在Java中，当一个类需要调用另一个类的方法时，通常需要在该类中实例化目标类的对象。这种设计可能导致循环依赖问题，例如：A类持有B类实例，B类持有C类实例，而C类又持有A类实例。这种情况下，若其中任何一个类出现问题，整个系统框架都可能受到影响。

Spring框架通过IOC（控制反转）机制解决了这个问题。IOC容器负责创建和管理所有对象（如A、B、C三个对象），其他类只需从容器中获取所需实例即可。这种方式有效降低了程序间的耦合度。

控制反转（Inversion of Control，简称IoC）是面向对象编程中的核心设计原则，其主要目的是降低代码间的耦合度。

核心价值：IoC通过反转程序控制权，有效解决了传统开发中模块间高耦合的问题。

2. IOC容器的底层原理

IOC的实现，依赖于以下3门技术

① dom4j解析xml文档；

② 工厂模式；

③ 采用反射设计模式创建对象

3.IOC容器

Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：

(1) BeanFactroy：IOC容器是Spring内部的使用接口，不提供给开发人员使用

* BeanFactroy:加载配置文件的时候不会去创建对象，在使用对象的时候才会去创建对象

(2)ApplicationContext:BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员进行使用

*ApplicationContext:加载配置文件的时候会把对象创建

四、：Spring框架的Bean管理

(1).什么是Bean个管理

Bean管理主要包含以下两个核心操作：

对象实例化
依赖注入

(2).Bean管理操作的两种方式

基于XML配置文件的实现方式
基于注解的实现方式

(3).基于xml配置文件的方式实现Bean管理和注入属性

1.基于xml方式创建对象

这是我们在上面已经配置过的内容
创建对象时，默认会调用无参构造方法来完成对象的初始化

2.基于xml方式注入属性

依赖注入概述

IOC与DI核心概念

IOC（控制反转）

将对象创建的控制权交由Spring框架管理

DI（依赖注入）

通过Spring容器完成对象属性的自动注入

实现方式：
定义类属性
提供对应的setter方法
在配置文件中配置属性注入

java 复制代码

public class User {
    // 编写成员属性，一定需要提供该属性的set方法
    //IOC容器底层就通过属性的set方法方式注入值
    private int age;
    private String name;
    private Demo demo;

    public void setAge(int age) {
        this.age = age;
    }

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

    public void setDemo(Demo demo) {
        this.demo = demo;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", demo=" + demo +
                '}';
    }
}

spring配置文件

XML 复制代码

<!‐‐DI：依赖注入‐‐>
<bean id="user" class="com.qcby.service.User" >
    <!--使用property完成属性注入
        name:类里面属性名称
        value:向属性注入值
        ref：对象映射-->
    <property name="age" value="18"></property>
    <property name="name" value="张三"></property>
    <property name="demo" ref="demo"></property>
</bean>

<bean id="demo" class="com.qcby.service.Demo" />

测试类

java 复制代码

@Test
public void run1(){
    //创建spring工厂，加载配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    //获取bean对象
    User user = ac.getBean("user", User.class);

    System.out.println(user.toString());

}

数组，集合(List,Set,Map)等的set注入

java 复制代码

public class CollectionBean {

    private String [] strs;
    private List<String> list;
    private Map<String,String> map;

    public void setStrs(String[] strs) {
        this.strs = strs;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "CollectionBean{" +
                "strs=" + Arrays.toString(strs) +
                ", list=" + list +
                ", map=" + map +
                '}';
    }
}

XML 复制代码

<!‐‐给集合属性注入值‐‐>
<bean id="collectionBean" class="com.qcby.service.CollectionBean">
    <property name="strs">
        <array>
            <value>美美</value>
            <value>小凤</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>熊大</value>
            <value>熊二</value>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="aaa" value="老王"/>
            <entry key="bbb" value="小王"/>
        </map>
    </property>
</bean>

属性构造方法方式注入值

java 复制代码

public class Car {
    // 名称
    private String cname;
    // 金额
    private Double money;

    public Car(String cname,Double money){
        this.cname = cname;
        this.money = money;
    }

    @Override
    public String toString() {
        return "Car{" +
                "cname='" + cname + '\'' +
                ", money=" + money +
                '}';
    }
}

XML 复制代码

<bean id="car" class="com.qcby.service.Car">
    <constructor-arg name="cname" value="奔驰"></constructor-arg>
    <constructor-arg name="money" value="35"></constructor-arg>
</bean>

数组，集合(List,Set,Map)等的构造器注入

java 复制代码

private String[] Strings;
private List<String> list;
private Map<String,String> map;

public UserService( String[] Strings, List<String> list, Map<String, String> map) {
    this.Strings = Strings;
    this.list = list;
    this.map = map;
}

XML 复制代码

<bean id="user" class="com.qcby.service.UserService">
    <constructor-arg name="address">
    <array>
        <value>北京</value>
        <value>上海</value>
        <value>广州</value>
    </array>
</constructor-arg>
<constructor-arg name="phone">
    <list>
        <value>18999845821</value>
        <value>18999845829</value>
        <value>18999845888</value>
    </list>
</constructor-arg>
<constructor-arg name="map">
    <map>
        <entry key="1" value="张三"/>
        <entry key="2" value="张三"/>
        <entry key="3" value="张三"/>
    </map>
</constructor-arg>
</bean>

(4).基于注解的方式实现Bean管理和注入属性

1.什么是注解

①：注解是代码特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值...)

②：使用注解，注解作用在类上面，方法上面，属性上边

③：使用注解的目的：简化XML配置

2.Spring针对Bean管理中创建对象提供的注解

@Component 普通的类

@Controller 表现层

@Service 业务层

@Repository 持久层

*上边四个功能一样，都可以用来创建bean实例

3.用注解的方式创建对象

①：编写接口和实现类

java 复制代码

public interface UserService {
    public void hello();
}

②：在需要管理的类上添加@Component注解

java 复制代码

import org.springframework.stereotype.Component;

/* <bean id="us" class="UserServiceImpl"/> */
/**
 * 组件，作用：把当前类使用IOC容器进行管理，如果没有指定名称，默认使用类名，首字母是小写。
 * userServiceImpl。或者自己指定名称
 **/
@Controller(value="us")
public class UserServiceImpl implements UserService {
    public void hello() {
        System.out.println("使用注解，方便吧！");
    }
}

③：编写配置文件，重点是开启注解扫描。

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"
       xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
   
    <!--开启注解扫描 com.qcby所有的包中的所有的类-->
    <context:component-scan base-package="com.qcby"/>
</beans>

编写测试方法

java 复制代码

import com.qcby.testanno.UserService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo2 {
    @Test
    public void run1(){
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContextanno.xml");
        UserService us = (UserService) ac.getBean("us");
        us.hello();
    }
}

4.用注解的方实现属性注入

@Value 用于注入普通类型（String，int，double等类型）

@Autowired 默认按类型进行自动装配（引用类型）

@Qualifier 不能单独使用必须和@Autowired一起使用，强制使用名称注入

@Resource Java提供的注解，也被支持。使用name属性，按名称注入

java 复制代码

@Component(value = "c")
// @Controller
// @Service(value = "c")
// @Repository(valu = "c")
public class Car {
    // 注解注入值，属性set方法是可以省略不写的。
    // 只有一个属性，属性的名称是value，value是可以省略不写的
    @Value("大奔2")
    private String cname;
    @Value(value = "400000")
    private Double money;
    // 也不用提供set方法
    // 按类型自动装配的注解，和id名称没有关系

    @Autowired
    // 按id的名称注入，Qualifier不能单独使用，需要Autowired一起使用。
    // @Qualifier(value = "person")
    // @Resource Java提供的注解，按名称注入对象，属性名称是name
    // @Resource(name = "person")
    private Person person;


    @Override
    public String toString() {
        return "Car{" +
                "cname='" + cname + '\'' +
                ", money=" + money +
                ", person=" + person +
                '}';
    }

}

(5). IOC纯注解的方式

纯注解的方式是微服务架构开发的主要方式，所以也是非常的重要。纯注解的目的是替换掉所有的配置文件。但是需要编写配置类。

常用的注解总结

@Configuration 声明是配置类

@ComponentScan 扫描具体包结构的

编写实体类

java 复制代码

@Component
public class Order {
    @Value("北京")
    private String address;
    @Override
    public String toString() {
        return "Order{" +
                "address='" + address + '\'' +
                '}';
    }
}

编写配置类，替换掉applicationContext.xml配置文件

java 复制代码

@Configuration
// 扫描指定的包结构
@ComponentScan(value = "com.qcby")
public class SpringConfig {
}

我们可以在元素中添加 scope 属性来配置 Spring Bean 的作用范围

Spring 5 共提供了 6 种 scope 作用域，如下表。

五、Bean的生命周期

在传统的 Java 应用中，Bean 的生命周期相对简单：通过 new 关键字实例化后即可使用，当 Bean 不再被引用时，Java 会自动进行垃圾回收。

而 Spring 框架中的 Bean 生命周期则更为复杂。Spring IOC 容器能够全面管理 Bean 的生命周期，并允许在特定阶段执行自定义任务。整个过程主要包含以下几个阶段：

创建bean对象：IOC容器初始化时，通过反射机制调用无参构造方法实例化bean；
属性注入：通过反射机制调用setter方法完成属性赋值；
初始化前处理：由bean后置处理器执行预处理操作；
初始化阶段：执行配置中指定的初始化方法；
初始化后处理：由bean后置处理器执行后续处理；
使用阶段：bean对象已就绪可用；
销毁阶段：执行配置中指定的销毁方法；
容器关闭：IOC容器终止运行。

Bean的初始化和销毁：

我们可以在 Spring Bean 生命周期的某个特定时刻，指定一些生命周期回调方法完成一些自定义的操作，对 Bean 的生命周期进行管理。

方式一：通过接口实现，在 Spring Bean 的 Java 类中，通过实现 InitializingBean 和 DisposableBean 接口，指定 Bean 的生命周期回调方法。

方式二：通过 XML 配置实现，在 Spring 的 XML 配置中，通过 `` 元素中的 init-method 和 destory-method 属性，指定 Bean 的生命周期回调方法。

方式三：使用注解实现。

注意：如果一个 Bean 中有多种生命周期回调方法时，优先级顺序为：注解 > 接口 > XML 配置。

Dog.java：

java 复制代码

public class Dog {

    private String name;

    private String owner;

    private int age;

    public Dog() {

    	System.out.println("Dog对象被创建...");

    }

    public String getName() {

    	return name;

    }

    public void setName(String name) {

    	System.out.println("调用setName方法....");

    	this.name = name;

    }

    public String getOwner() {

    	return owner;

    }
    public void setOwner(String owner) {

    	System.out.println("调用setOwner方法....");

    	this.owner = owner;

    }

    public int getAge() {

    	return age;

    }

    public void setAge(int age) {

    	System.out.println("调用setAge方法....");

    	this.age = age;

    }

    @Override

    public String toString() {

    	return "Dog{" +

    		"name='" + name + '\'' +

    		", owner='" + owner + '\'' +

    		", age=" + age +

    	'}';

    }
}

使用p命名空间

XML 复制代码

<bean id="dog" class="com.gs.bean.Dog" p:name="旺财" p:owner="小明" p:age="5"/>

测试：

java 复制代码

public class LifeCycleTest {

    @Test

    public void testLifeCycle() {

    	System.out.println("-------容器初始化阶段---------");

    	ClassPathXmlApplicationContext ac = new

    	ClassPathXmlApplicationContext("applicationContext.xml");

    	System.out.println("-------对象使用阶段---------");

    	Dog dog = ac.getBean("dog", Dog.class);

    	System.out.println(dog);

    	System.out.println("-------容器关闭阶段---------");

    	//手动关闭容器

    	ac.close();//ApplicationContext没有close()

    }

}

通过接口实现

我们可以在 Spring Bean 的 Java 类中，通过实现 InitializingBean 和 DisposableBean 接口，指定Bean 的生命周期回调方法。

注意：通常情况下，我们不建议通过这种方式指定生命周期回调方法，这是由于这种方式会导致代码的耦合性过高。

在dog类加入

java 复制代码

/**

    * 初始化回调逻辑

    *

    * @throws Exception

    */

    @Override

    public void afterPropertiesSet() throws Exception {

    	System.out.println("调用接口：InitializingBean，方法：afterPropertiesSet，无参数");

    }

    /**

    * 销毁回调逻辑

    *

    * @throws Exception

    */

    @Override

    public void destroy() throws Exception {

    	System.out.println("调用接口：DisposableBean，方法：destroy，无参数");

    }

通过 XML 配置实现

我们还可以在 Spring 的 XML 配置中，通过元素中的 init-method 和 destory-method 属性，指定 Bean 的生命周期回调方法。

XML 复制代码

<bean id="dog" class="com.qcby.Dog" p:name="admin" p:owner="aaa"
      p:age="18" init-method="大阿萨大师"
                 destroy-method="就打卡大事件"/>

Bean的后置处理器

创建后置处理器类：

java 复制代码

// 声明一个自定义的bean后置处理器

// 注意：bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行

public class MyBeanProcessor implements BeanPostProcessor {

    @Override

    public Object postProcessBeforeInitialization(Object bean, String beanName)throws BeansException {

    	System.out.println("☆☆☆" + beanName + " = " + bean);

    	return bean;

    }

    @Override

    public Object postProcessAfterInitialization(Object bean, String beanName)throws BeansException {

    	System.out.println("★★★" + beanName + " = " + bean);

    	return bean;

    }

}

把 bean 的后置处理器放入 IOC 容器：

XML 复制代码

<!-- bean的后置处理器要放入IOC容器才能生效 -->

<bean id="myBeanProcessor" class="com.gs.process.MyBeanProcessor"/>

XML 复制代码

<dependency>

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

<version>1.18.12</version>

<scope>provided</scope>

</dependency>