Spring(二)-生命周期 + 自动装配(xml) +自动装配(注解)

1、生命周期

**Spring容器的 bean **的生命周期；

1.1 默认生命周期

1.1.1 生命周期

1. 调用构造方法，创建实例对象；
2. set方法，给实例对象赋值；
3. init 初始化方法 初始化对象；(手写并配置到bean上init-method="")
4. 使用容器中的bean对象；
5. destroy 销毁方法 销毁对象 (手写并配置到bean上destroy-method="")

1.1.2 bean 实体类

Truck

@Data
@ToString
public class Truck {

    //品牌
    private String brand;
	//厂商
    private String factory;
	//价格
    private Double price;

    public Truck() {
        //空参构造方法，观察bean什么时候实例化
        System.out.println("------ 1.调用构造方法，创建实例对象 ------\n");
    }

    public void setBrand(String brand) {
        //任意一个set方法，观察bean什么时候注入参数
        System.out.println("------ 2.set方法，给实例对象赋值 ------");
        this.brand = brand;
    }

    public  void  initTruck(){
        //init初始化方法，观察bean什么时候初始化
        //需要再配置bean的时候，配置init初始化方法
        System.out.println("------ 3.Truck init 初始化方法 初始化对象 ------\n");
        this.brand = "大运";
    }

    public  void  destroyTruck(){
        //destory方法，观察bean什么时候销毁
        //需要再配置bean的时候，配置destory销毁方法
        System.out.println("------ 5.Truck destroy 销毁方法 销毁对象 ------\n");
    }
	//这里方法上标注的序号是测试后得来的；
}

1.1.3 bean 配置

spring-lifecycle.xml

<!-- spring容器中bean的生命周期  默认生命周期 -->
<bean id="truck" class="com.kgc.spring.lifecycle.Truck" init-method="initTruck" destroy-method="destroyTruck">
    <property name="brand" value="江淮"></property>
    <property name="factory" value="安徽"></property>
    <property name="price" value="200000"></property>
</bean>

1.1.4 测试

public class TestSpringLifeCycle {

    //定义全局容器对象,如果需要关闭容器对象，
    //必须使用ApplicationContext的子接口 ConfigurableApplicationContext
    //ApplicationContext接口主要各种属性的get方法;
    //ConfigurableApplicationContext重在对各种属性的配置;

//    private ApplicationContext context;
    private ConfigurableApplicationContext context;

    @Before
    public void initApplicationContext(){
        context = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
    }

    //测试spring 容器的bean的生命周期，默认和加了处理器两种场景
    @Test
    public void  testSpringBeanLifeCycle(){

        //从容器中，获取Truck的是实例对象
        Truck truck = context.getBean("truck", Truck.class);

        //使用对象
        System.out.println("------ 4.使用容器中的bean对象"+truck +" ------");

        //关闭容器
        context.close();

    }

}

输出结果：

//可以得出 spring中bean的 默认生命周期
------ 1.调用构造方法，创建实例对象 ------

------ 2.set方法，给实例对象赋值 ------

------ 3.Truck init 初始化方法 初始化对象 ------

------ 4.使用容器中的bean对象Truck(brand=大运, factory=安徽, price=200000.0) ------

------ 5.Truck destroy 销毁方法 销毁对象 ------

1.1.5 ApplicationContext 和 ConfigurableApplicationContext

参考博客：ApplicationContext和ConfigurableApplicationContext解析

• ApplicationContext接口主要 各种属性的get方法;

• ConfigurableApplicationContext重在对 各种 属性的配置;

1.2 增加后置处理器

1.2.1 生命周期

​ 1.调用构造方法，创建实例对象；

​ 2.set方法，给实例对象赋值;

​ 3-1.后置处理的 before 方法;

​ 3.初始化方法 初始化对象;

​ 3+1.后置处理器的的 after 方法;

​ 4.使用容器中的bean对象;

​ 5.destroy 销毁方法 销毁对象;

1.2.2 后置处理器

• 要求：必须实现 BeanPostProcessor 接口

• 自定义 bean 的 后置处理器，对容器中所有的bean统一处理(生效)，

• 要生效的话，必须将此处理器放到容器中(配置到spring的核心配置文件中，增加处理器的实例配置);

注意：当前案例，只对容器中的一个实例处理；

MyBeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //在容器中bean的实例对象调用 初始化方法 前 自动调用（init方法可以没有，不影响）
        //模拟处理容器中的bean，接下来的写法，仅限于当前的用法案例（容器中就 只有一个 卡车实例）
        Truck truck = (Truck)bean;

        System.out.println("++++++ 容器中的卡车对象 "+truck+"++++++");

        System.out.println("++++++ 3-1,后置处理的 before 方法 ++++++");
        truck.setBrand("后置处理的before方法");
        System.out.println("++++++ 处理后的 卡车对象 "+truck+" ++++++\n");

        return truck;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //bean 初始化方法 执行 后，调用此方法处理bean
        Truck truck = (Truck)bean;

        System.out.println("++++++ 初始化容器中的卡车对象 "+truck+"++++++");

        System.out.println("++++++ 3+1,后置处理器的的 after 方法 ++++++");
        truck.setBrand("after");
        System.out.println("++++++ 初始化后 处理后的 卡车对象 "+truck+" ++++++\n");
        return truck;

    }
}

1.2.3 bean 配置

在配置文件中配置 MyBeanPostProcessor；

<!-- 配置后置处理器的实例，自动放入容器中，可以自动生效 (容器中所有的实例生效) -->
<bean class="com.kgc.spring.lifecycle.MyBeanPostProcessor"></bean>

1.2.4 测试

跟默认生命周期的测试代码一致；

输出结果：

------ 1.调用构造方法，创建实例对象 ------

------ 2.set方法，给实例对象赋值 ------
++++++ 容器中的卡车对象 Truck(brand=江淮, factory=安徽, price=200000.0)++++++

++++++ 3-1,后置处理的 before 方法 ++++++ ------ 2.set方法，给实例对象赋值 ------
++++++ 处理后的 卡车对象 Truck(brand=后置处理的before方法, factory=安徽, price=200000.0) ++++++

------ 3.Truck init 初始化方法 初始化对象 ------
++++++ 初始化容器中的卡车对象 Truck(brand=大运, factory=安徽, price=200000.0)++++++

++++++ 3+1,后置处理器的的 after 方法 ++++++ ------ 2.set方法，给实例对象赋值 ------
++++++ 初始化后 处理后的 卡车对象 Truck(brand=after, factory=安徽, price=200000.0) ++++++

------ 4.使用容器中的bean对象Truck(brand=after, factory=安徽, 

------ 5.Truck destroy 销毁方法 销毁对象 ------

1.2.3 BeanPostProcesso

参考博客：BeanPostProcessor简介

BeanPostProcessor官方定义为工厂钩子，我们也俗称后置处理器。它允许自定义修改新的bean实例，例如检查标记接口或用代理包装它们。应用程序上下文可以在其bean定义中自动检测BeanPostProcessor bean，并将它们应用于随后创建的任何bean。

BeanPostProcessor 的 前置处理 和 后置处理；

 +自动装配(注解).assets/image-20220826150821502.png)

2、自动装配(xml)

2.1 bean 实体类

Person

@Data
public class Person {
    //昵称
    private String nickName;
    //车子
    private Car car;
    //房子
    private House house;
}

Car

@Data
public class Car {
    //品牌
    private String brand;
	//厂商
    private String factory;
	//价格
    private Double price;
}

House

@Data
public class House {
    //户型
    private  String type;
    //面积
    private double area;
    //价格
    private  Integer price;
}

2.2 bean 配置 （byType）

autowire="byType"：根据属性 的 类型自动装配；

spring-auto.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.xsd">

    <!-- spring的自动装配方式，基于xml配置文件方式，掌握 -->
    <!-- 容器中实例化一个容器的Car对象 -->
    <bean id="car" class="com.kgc.spring.auto.Car">
        <property name="brand" value="Bnw520"></property>
        <property name="factory" value="华晨"></property>
        <property name="price" value="450000"></property>
    </bean>

    <!-- 容器中实例化一个容器的House对象 -->
    <bean id="house" class="com.kgc.spring.auto.House">
        <property name="type" value="三室一厅"></property>
        <property name="area" value="96"></property>
        <property name="price" value="2800000"></property>
    </bean>

    <!-- 根据类型自动装配 -->
    <bean id="person" class="com.kgc.spring.auto.Person" autowire="byType">
        <property name="nickName" value="huayu"></property>
    </bean>

</beans>

2.3 测试

public class TestSpringAutoUserXml {
    private ApplicationContext context;

    @Before
    public void initApplicationContext(){
        context = new ClassPathXmlApplicationContext("spring-auto.xml");
    }

    @Test
    public  void testSpringAuto(){
        Person person = context.getBean("person", Person.class);

        //使用对象
        System.out.println("容器中的person对象："+person);

    }

}

输出结果：

容器中的person对象：Person(
    					nickName=huayu,
                        car=Car(brand=Bnw520, factory=华晨, price=450000.0),
                        house=House(type=三室一厅, area=96.0, price=2800000)
						)

2.4 bean 配置 (多个同类型bean)

bean 配置:

其他不变，多增加一个Car类型的实例bean；

<bean id="car" class="com.kgc.spring.auto.Car">
    <property name="brand" value="Bnw520"></property>
    <property name="factory" value="华晨"></property>
    <property name="price" value="450000"></property>
</bean>

<bean id="carNew" class="com.kgc.spring.auto.Car">
    <property name="brand" value="AudiA6"></property>
    <property name="factory" value="一汽"></property>
    <property name="price" value="450000"></property>
</bean>

测试，报错信息：

No qualifying bean of type 'com.kgc.spring.auto.Car' available: expected single matching bean but found 2: car,carNew

总结：autowire="byType" 当有多个相同类型的bean时，无法确定要装配的 bean;

2.5 bean 配置（byName）

其他配置信息不变，设置 autowire="byName" ，根据 属性 的 名字 自动装配；

<bean id="person" class="com.kgc.spring.auto.Person" autowire="byName">
    <property name="nickName" value="hauyu"></property>
</bean>

测试输出结果：

容器中的person对象：Person(
    					nickName=huayu,
                        car=Car(brand=Bnw520, factory=华晨, price=450000.0),
                        house=House(type=三室一厅, area=96.0, price=2800000)
						)

总结：

• byType:根据类型自动装配：
  • 根据实体属性的  类型，到容器中，根据  bean类型  进行唯一匹配，如果可以匹配到对应类型的bean的实例，就会执行自动装配， 如果不能唯一匹配(同类型的bean有多个)，会报错；
• byName: 根据名称自动装配：
  • 根据属性的 属性名，到容器中，根据 bean的id 属性值，进行唯一匹配，如果能够成功匹配，执行自动装配， 如果匹配不到，不执行自动装配，实体属性为null;

3、自动装配 (注解)

3.1 注解

• @Component 普通组件注解；
• @Repository 持久层注解
• @Service 业务层注解
• @Controller 控制层注解

3.3.1 注解的原理

默认情况下：spring自动将分层组件(@Controller,@Service,@Repository,@component)标识的类(不是接口)，自动创建实例对象放入容器中，使用bean的标识id值为 对应类名首字母小写 就相当于，帮我们手动添加了配置 :

<bean id="分层注解标识类的类名首字母小写" class="分层注解标识类的全类名"> ... <bean>

3.1.2 自定义id 属性

如果不想使用默认的类名首字母小写，我们可以使用注解的value属性执行一个自定义的id值;

比如:@Service(value="自定义的id值")，注解只有value属性，可以省略value执行，简化为@Service("自定义的id值")

3.1.3 分层组件的目的

分层组件的目的，就仅仅是为了方便开发人员明确当前注解所在的类所对应的角色，在使用上，建议使用，按照官方定义的使用，防止模糊不清；在springMVC框架中@Controller有特殊含义；

3.2 配置文件

spring创建容器对象时，如果解析到 component-scan 组件扫描配置，会将base-package指定的基包(父包)及其子包所有增加了分层组件的类，自动创建实例，放进容器中；

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       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
">
 <!-- 组件扫描：注解标识的组件，必须通过组件扫描配置，才可以添加到spring的容器中-->
 <context:component-scan base-package="com.kgc.spring.acnocation" >    </context:component-scan>

</beans>

3.3 默认id属性 测试

3.3.1 实体

@Component
public class User {
    //用户名
    @Value("huayu") //@Value()  自动装配参数
    private  String userName;
    //用户密码
    @Value("123")
    private String userPwd;
}

3.3.2 测试

@Test
public  void testSpringAutoUserAnnotation(){

    User user = context.getBean("user", User.class);

    System.out.println(user);
    //User(userName=huayu, userPwd=123)

}

3.4 自定义id属性 测试

3.4.1 实体(自定义id属性)

@Component(value = "myUser")
public class User {
    //用户名
    private  String userName;
    //用户密码
    private String userPwd;
}

3.4.2 测试

@Test
public  void testSpringAutoUserAnnotation(){

    //User user = context.getBean("user", User.class);
    //自定义id后，默认id不能使用: No bean named 'user' available

    //必须使用自定义id
    User user = context.getBean("myUser", User.class);

    System.out.println(user);
    //User(userName=huayu, userPwd=123)

}

3.5 自动装配

3.5.1 @Autowired

• 组件自动装配，可以实现实体属性类型的自动装配，自动到spring的容器中，根据当前属性的类型或者名称进行注入，如果容器中能匹配到，就直接将实例对象注入到当前实体属性上，无序手动指定;
• @Autowired自动装配原理：首先会根据byType方式，进行自动装配，
  • 如果不能唯一匹配（存在同类型多个实例对象），会再次尝试使用byName方式，根据当前实体属性名，到容器中进行匹配（容器中bean的id值）,如果能唯一匹配，直接执行自动装配，
• 默认情况下，@Autowired注解标识的实体属性，必须被装配
  • 如果装配失败，就直接抛出异常;
  • 如果不需要校验必须被装配（项目启动，如果装配失败，项目是起不来）;
  • 通过指定required = false，去除必须执行自动装配的校验（即便容器中找不到装配的实例，也不会抛出异常）;
• 如果自动装配，容器中存在多个同类型的bean对象，可以使用注解@Qualifier("容器中同类型多个bean的某个id值")，实现指定到容器中，找对应的bean实例对象，进行自动装配;
• 底层是如何做的：在指定要扫描的包时，<context:component-scan> 元素会自动注册一个bean的后置处理器：AutowiredAnnotationBeanPostProcessor的实例。该后置处理器可以自动装配标记了@Autowired、@Resource或@Inject注解的属性。

3.5.2 实体

People

@Data
@Component("myPeople")
public class People {
    //昵称
    @Value("huayu")
    private String name;
    //玩具
    @Autowired
    private Toy toy;

}

Toy接口

public interface Toy {
    //得到玩具
    public void getToy();

}

ToyImpl1

@Component("toy1")
public class ToyImpl1 implements Toy {

    @Value("玩具车")
    private String toyName;

    @Override
    public void getToy() {
        System.out.println(this.toyName);
    }
}

3.5.3 测试

注意:可以通过接口类型获取实现类(推荐使用)；

@Test
public  void testAutowired  (){
    People people = context.getBean("myPeople", People.class);

    people.getToy().getToy(); //玩具车

}

3.5.4 存在多个相同类型的bean

当存在多个相同类型的bean，不能唯一匹配，会自动装配错误；

在写一个Toy实现类，ToyImpl2

@Component("toy2")
public class ToyImpl2 implements Toy {

    @Value("尤克里里")
    private String toyName;

    @Override
    public void getToy() {
        System.out.println(this.toyName);
    }

}

3.5.4.1 测试

报错信息(项目无法启动)：

No qualifying bean of type 'com.kgc.spring.acnocation.bean.Toy' available: expected single matching bean but found 2: toy1,toy2

主要信息：类型无法唯一匹配；

3.5.4.2 required = false 允许不装配

People

@Data
@Component("myPeople")
public class People {

    //昵称
    @Value("huayu")
    private String name;

    //玩具
    @Autowired (required = false)
    private Toy toy;

}

项目可以启动但是还是报错(一般项目中不会有两个相同类型的实现类;)

3.5.4.3 @Quailfy

People

@Data
@Component("myPeople")
public class People {

    //昵称
    @Value("huayu")
    private String name;

    //玩具
    @Autowired
    @Qualifier("toy2") //指定bean的id值
    private Toy toy;

}

3.5.4.4 测试

@Test
public  void testAutowired  (){
    People people = context.getBean("myPeople", People.class);

    System.out.println(people.getToy());
    //com.kgc.spring.acnocation.bean.ToyImpl2@15d9bc04

    people.getToy().getToy();
    //尤克里里

}

3.6 指定扫描 排除扫描

3.6.1 指定扫描

include-filter

指定扫描(包含扫描)：

• 只会扫描指定的类或者某类组件(使用分组扫描)，加入到容器中；
• 但是必须配合父标签的user-default-filter使用，默认值是true，就是全部扫描；
• 指定扫描，如果要生效必须改为false；
• 指定扫描某类组件，type="annotation" expression="某类组件注解的全类名"；
• 指定扫描某个类，type="assignable" expression="某个类的全类名"；

3.6.1.1 指定扫描某类组件

type="annotation"

• org.springframework.stereotype.Component
• org.springframework.stereotype.Repository
• org.springframework.stereotype.Service
• org.springframework.stereotype.Controller

<!-- 指定扫描 @Component 组件 -->
<context:component-scan base-package="com.kgc.spring.acnocation" use-default-filters="false" >
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
</context:component-scan>

3.6.1.2 指定扫描某个类

type="assignable"

<!-- 指定扫描 ToyImpl1 -->
<context:component-scan base-package="com.kgc.spring.acnocation" use-default-filters="false" >
    <context:include-filter type="assignable" expression="com.kgc.spring.acnocation.bean.ToyImpl1"/>
</context:component-scan>

3.6.2 排除扫描

exclude-filter

• 排除扫描(剔除扫描)：排除指定的类或某类组件，不加入到容器中，处理排除外的其他组件，仍然会被添加到容器中；
• 不需要配合父标签，use-default-filters="true" 因为，默认就是在全部扫描的基础上剔除；
• 排除扫描某类组件，type="annotation" expression="某类组件注解的全类名"；
• 排除扫描某个类，type="assignable" expression="某个类的全类名"；

3.6.2.1 排除扫描某类组件

type="annotation"

<!-- use-default-filters="true" 可写可不写 -->
<!-- 排除扫描 @Component组件 -->
<context:component-scan base-package="com.kgc.spring.acnocation" use-default-filters="true" >
	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
</context:component-scan>

3.6.2.2 排除扫描个类

type="assignable"

<!-- 排除扫描 ToyImpl1 -->
<context:component-scan base-package="com.kgc.spring.acnocation" >
	<context:exclude-filter type="assignable" expression="com.kgc.spring.acnocation.bean.ToyImpl1"/>
</context:component-scan>