ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

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

2022-08-28 10:02:20  阅读：140  来源： 互联网

标签：装配 xml 容器 对象 private bean 自动 ------ public


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 的 前置处理 和 后置处理；

![image-20220826150821502](Spring-02 生命周期 + 自动装配(xml) +自动装配(注解).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>

标签：装配,xml,容器,对象,private,bean,自动,------,public
来源： https://www.cnblogs.com/xiaoqigui/p/16632269.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有