Spring核心技术详解(二)

最新推荐文章于 2022-10-01 13:27:07 发布
最新推荐文章于 2022-10-01 13:27:07 发布
阅读量281 收藏 1
点赞数
分类专栏： Spring 文章标签： spring xml方式注入

文章参考自：https://blog.csdn.net/c99463904/article/details/73003558

一、基于XML方式在Ioc容器装配Bean

为了让IoC容器帮我们创建和管理对象，我们必须在Spring IoC容器中装配好Bean，并建立好Bean和Bean之间的关联关系。Spring启动时读取应用程序提供的Bean配置信息，并在Spring容器中生成一份相应的Bean配置注册表，然后根据这张注册表实例化Bean，装配好Bean之间的依赖关系。

1、Bean的基本配置
<!-- id:Bean的名称; class:指定了Bean对应的实现类 -->
<bean id=“userdaoid” class=“UserDao”/>
2、Bean的命名

　　一般情况下，配置Bean时需要为其指定一个id属性作为Bean的名称。id在IoC容器中必须是唯一的。id的命名需要满足xml的命名规范：必须以字母开始，后面可以使字母数字、下划线、句号、冒号等符号，逗号和空格等字符是非法的。

　　还有一个name属性，和id属性作用一样，但是name几乎可以使用任何字符。Spring配置文件中不允许出现相同的id，却允许出现相同的name。如果有相同的name，通过getBean(beanName)获取Bean时，将返回最后生命的Bean，原因是最后的Bean覆盖了前面同名的Bean。一般地，应该尽量使用id。

3、Bean的实例化方式
  • 使用默认的无参构造方法实例化
 // 创建一个类
public class User{
}  

 // 配置xml文件
<bean id="user" class="com.cad.domain.User" ></bean>
  • 使用默认的无参构造方法实例化
    工厂方法是非静态的，即必须实例化工厂类后才能调用工厂方法。
// 创建一个工厂类，提供一个普通的方法，返回指定的对象
public class UserFactory {
    public  User getUser(){
        return new User();
    }
}

//------------------------------- 配置xml文件 ---------------------------------

//先要实例工厂
<bean id="factory" class="com.cad.domain.UserFactory" ></bean> 
//通过实例化工厂调用工厂方法获取对象，factory-bean属性引用工厂实例，factory-method指定工厂方法
<bean id="user" factory-bean="factory" factory-method="getUser"></bean>
  • 使用静态工厂方法实例化
    工厂类方法是静态的，可以不用创建工厂类实例直接使用。
// 创建一个工厂类，提供一个静态方法，返回指定的对象
public class UserFactory {
    public static User getUser(){
        return new User();
    }
}

//------------------------------- 配置xml文件 ---------------------------------

//class指定工厂类，factory指定工厂方法
<bean id="user" class="com.cad.domain.UserFactory" factory-method="getUser"></bean>
4、Bean的属性注入

　　Spring支持两种依赖注入方式，分别是属性注入和构造方法注入。用户不但可以将String，int等类型参数注入到Bean中，还可以将集合、Map类型注入到Bean中。

  • 属性注入(使用属性的set方法)
// 属性注入要求Bean提供一个默认的构造方法，并为需要注入的属性提供对应的set方法。
// Spring调Bean的默认构造方法创建对象，然后通过反射的方式调用set方法注入属性。 

// 创建类
public class User {
    private String username;
    public void setUsername(String username){
        this.username=username;
    }
    public void speak(){
        System.out.println("my name is"+username);
    }
}

//------------------------------- 配置xml文件 ---------------------------------

<bean id="user" class="com.cad.domain.User"> 
<!--<property>对应一个属性，name是属性的名称，value是属性的值，ref用来引用其他bean-->
    <property name="username" value="张三"></property>
</bean>
  • 使用有参数构造方法注入
// 使用构造方法注入前提是Bean必须提供带参的构造方法。 
//创建User类
public class User {
    private String username;
    public User(String username){
        this.username=username;
    }
    public void speak(){
        System.out.println("my name is"+username);
    }
}

//------------------------------- 配置xml文件 ---------------------------------
<bean id="user" class="com.cad.domain.User">
    <!--<constructor-arg>标签对应构造方法的参数，name是参数名称，value是参数值-->
    <constructor-arg name="username" value="jack"></constructor-arg>
</bean>
  • 注入null值
    如果需要为某个属性注入null值，必须使用专用的标签。
// 如果需要为某个属性注入null值，必须使用专用的<null/>标签。
<bean id="userdaoid" class="UserDao"> 
    <property name="username"><null/></property>
</bean>
  • 注入集合类型
    java.util包中的集合类是最常用的数据结构类型。主要包括List、Set、map、Properties等，Spring为这些集合提供了专门的标签来配置。
// 我们创建一个类，包含了各种集合类型 
public class CollectionDemo {
    private List<String> list; 
    private Set<String> set; 
    private Map<String,String> map; 
    private Properties properties;

    public List<String> getList() {
        return list;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public Set<String> getSet() {
        return set;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public Properties getProperties() {
        return properties;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public String toString() {
        return "CollectionDemo [list=" + list + ", set=" + set + ", map=" + map + ", properties=" + properties + "]";
    } 
}

//------------------------------- 配置xml文件 ---------------------------------

<bean id="collid" class="com.cad.domain.CollectionDemo"> 
    <!--配置list集合-->
    <property name="list">
        <list>
            <value>张三</value>
            <value>李四</value>
        </list> 
    </property> 

    <!--配置set集合-->
    <property name="set">
        <set>
            <value>java</value>
            <value>c#</value>
        </set>
    </property> 

    <!--配置map集合-->
    <property name="map">
        <map>
            <entry key="jack" value="杰克"></entry>
            <entry key="tom"  value="汤姆"></entry>
        </map>
    </property> 

    <!--配置properties类型-->
    <property name="properties">
        <props>
            <prop key="prop1">prop1</prop>
            <prop key="prop2">prop2</prop>
        </props>
    </property>
</bean>
5、使用p命名空间

　　为了简化Xml的配置，Spring引入了一个P命名空间。

  • 未使用P命名空间之前:
// 创建一个User类
public class User {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void say(){
        System.out.println(name+":"+age);
    }
} 
<!-- 配置文件 -->
<?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">

    <bean id="user" class="com.cad.domain.User">
        <property name="name" value="张三"></property>
        <property name="age" value="18"></property>
    </bean>
</beans>
  • 使用P命名空间之后:
<!-- 配置文件 -->
<?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">

    <!--使用p:属性名="xxx" 或者 p:属性名-ref="引用id"来指定属性-->
    <bean id="user" class="com.cad.domain.User" p:name="李四" p:age="88"/>
</beans>
6、Bean的作用域

　　Bean的作用域会对Bean的生命周期和创建方式产生影响，其一共有五种作用域：
　　这里写图片描述
  当作用域设置成singleton是获得的两个对象是一样的

// 我们来演示一下，将User类的作用域设置为singleton
<bean id="user" class="com.cad.domain.User" p:name="李四" p:age="88" scope="singleton"/>

public class Test {
    @org.junit.Test
    public void test(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        User user1=(User) ac.getBean("user");  //获得的两个对象是一样的
        User user2=(User) ac.getBean("user"); 
        System.out.println(user1);
        System.out.println(user2);
    }
}/**Output
        com.cad.domain.User@1c3a4799
        com.cad.domain.User@1c3a4799
**/

  作用域设置为多例

// 将User的作用域设置为多例
<bean id="user" class="com.cad.domain.User" p:name="李四" p:age="88" scope="prototype"/>

// 输出 
com.cad.domain.User@5d76b067
com.cad.domain.User@2a17b7b6
7、FactoryBean

　　我们前面的都是普通bean，Spring利用反射机制通过bean的class属性来实例化Bean。如果有的Bean属性特别多，我们就需要编写大量的配置信息。Spring提供了一个FactoryBean接口。我们可以通过实现该接口来返回特定的Bean，该接口定义了三个方法：

  • T getObject()：返回由FactoryBean创建的Bean实例。

  • boolean isSingleton()：确定创建的Bean的作用域是singleton还是prototype

  • Class< ? > getObjectType()：返回FactoryBean创建Bean的类型

// 我们创建一个类实现FactoryBean接口 
public class UserFactory implements FactoryBean<User> {

    //返回对象
    public User getObject() throws Exception {
        User user=new User();
        user.setAge(14);
        user.setName("tom");
        return user;
    }

    //返回bean的类型
    public Class<User> getObjectType() {
        return User.class;
    }

    public boolean isSingleton() {
        // TODO Auto-generated method stub
        return false;
    }
}
// 配置 
<bean id="userfactory" class="com.cad.domain.UserFactory"></bean>
//测试 
public class Test {
    @org.junit.Test
    public void test(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        User user=(User) ac.getBean("userfactory"); 
        user.say();
    }
}/**Output
        tom:14 
**/

  当我们标签的class属性配置的类实现了FactoryBean接口时，通过getBean返回的就不是该类本身，而是getObject()方法所返回的对象，相当于getObject()方法代理了getBean()。


二、Bean的生命周期

这里写图片描述
这里写图片描述
步骤如下:

1)、实例化BeanFactoryPostProcessor，调用postProcessBeanFactory()方法对工厂定义信息进行后处理。

2)、调用者通过getBean向容器请求bean时，如果容器注册了InstantiationAwareBeanPostProcessor接口，在实例化Bean之前，会调用接口的postProcessBeforeInstantiation()方法。

3)、根据配置文件调用Bean的构造方法或者工厂方法实例化Bean。

4)、实例化Bean后，调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInstantiation()方法，在这里可以对已经实例化的对象进行一些修饰。

5)、如果Bean配置了属性信息，在设置每个属性之前将先调用InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法。

6)、调用Bean的属性设置方法为Bean设置属性。

7)、如果Bean实现了BeanNameAware接口，会调用该接口的setBeanName()方法，将配置文件中该Bean对应的名称设置到Bean中。

8)、如果Bean实现了BeanFactoryAware接口，会调用该接口的setBeanFactory方法，将BeanFactory容器实例设置到Bean中。

9)、如果BeanFactory装配了BeanPostProcessor后处理器，将调用Object postProcessBeforeInitialization(Object bean,String beanName)方法对Bean进行加工操作，bean是当前处理的Bean，beanName是当前bean的配置名，返回的对象是加工处理后的Bean。用户可以使用该方法对Bean进行特殊处理。BeanPostProcessor在Spring框架中占有重要地位，AOP等都通过该BeanPostProcessor实施。

10)、如果Bean实现了InitializingBean接口，会调用该接口的afterPropertiesSet()方法。

11)、如果中配置了init-method属性，执行指定的初始化方法。

12)、调用BeanPostProcessor后处理器的Object postProcessAfterInitialization(Object bean,String beanName)方法再次获得对Bean的加工处理机会。

13)、将Bean返回给调用者。

14)、当容器关闭时， 如果Bean实现了DisposableBean接口，调用接口的destory方法。

15)、如果设置了destory-method属性，执行指定的销毁方法。

1、生命周期中方法的划分

　　Bean的完整生命周期从Spring容器着手实例化bean开始，直到销毁Bean。其中有很多关键的方法。
这些方法大致分为三类：

  • Bean自身的方法：如Bean的构造方法，调用set方法设置属性，和init-method和destory-method指定的方法。

  • Bean的生命周期接口方法：如BeanNameAware、BeanFactoryAware、InitializingBean、DisposableBean等接口的方法由Bean自己直接实现

  • 容器级生命周期接口方法：如InstantiationAwareBeanPostProcessor和BeanPostProcessor接口，一般称为后处理器。这些接口的实现类与Bean无关，直接装配到Spring容器中。当Spring容器创建任何Bean时，这些后处理器都会起作用。

2、测试Bean生命周期的例子
//实现Bean级生命周期接口
public class User implements BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean{
    private String name;
    private int age;

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

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

    public void myinit(){
        System.out.println("初始化..."); 
        name="王五";
        age=55;
    }  

    public void say(){
        System.out.println(name+":"+age);
    }

    public void mydestory(){
        System.out.println("销毁中...");
    }

    public void destroy() throws Exception {
        System.out.println("听说我是最后被调用");

    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("听说我是第三个被调用");

    }

    public void setBeanName(String arg0) {
        System.out.println("听说我是第一个被调用");

    }

    public void setBeanFactory(BeanFactory arg0) throws BeansException {
        System.out.println("听说我是第二个被调用");

    }
}
<!--我们在配置时配置init-method和destory-method属性来指定初始化和销毁的方法-->
<bean id="user" class="com.cad.domain.User" init-method="myinit" destroy-method="mydestory"></bean> 
// 我们进行测试
public class Test {
    @org.junit.Test
    public void test(){
        ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        User user=(User) ac.getBean("user");  
        user.say();
        //destory方法执行必须在容器关闭之后才能执行
        ac.close();
    }
}

执行结果如下：

这里写图片描述

3、装配后处理器
//提供BeanPostProcessor的实现类
public class MyBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessAfterInitialization(Object arg0, String arg1) throws BeansException {
        System.out.println("后处理器：初始化方法之后执行");
        return arg0;
    }

    public Object postProcessBeforeInitialization(Object arg0, String arg1) throws BeansException {
        System.out.println("后处理器：初始化方法之前执行");
        return arg0;
    }

}
<!--在配置文件中装配后处理器-->
<bean id="myBeanPostProcessor" class="com.cad.domain.MyBeanPostProcessor"></bean> 
// 我们进行测试
public class Test {
    @org.junit.Test
    public void test(){
        ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        User user=(User) ac.getBean("user");  
        ac.close();
    }
}

仔细观察输出结果，就会发现验证了我们说的Bean的生命周期过程：
这里写图片描述

4、关于Bean生命周期接口的一些问题

　　通过实现Bean的生命周期接口对Bean进行额外的一些控制，虽然具有一些优点，但是带来了一个很严重的问题，我们的类必须实现这些接口，Bean和Spring紧密的结合在了一起，这就带来了很大的麻烦，所以，我们一般不使用这些接口，而是通过的init-method和destory-method属性来达到我们的初始化和销毁效果，达到框架解耦的问题。

　　此外，BeanPostProcessor接口是像插件一样注册到Spring容器中，使应用与框架解耦，同时可以为我们完成一些额外的功能。例如可以获取动态代理，还有实现AOP功能。

zhumqs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
七个Spring核心模块详解
08-27
Spring核心模块详解 Spring框架是Java应用程序的核心框架，提供了七个核心模块，分别是Spring Core、Spring AOP、Spring Context、Spring DAO、Spring ORM、Spring Web和Spring MVC。这些模块提供了不同的功能，...
Spring Boot核心技术-笔记整理
最新发布
05-27
### Spring Boot核心技术详解 #### 一、Spring Boot简介与入门 **Spring Boot** 是一个基于Spring框架的简化工具，旨在让开发者更容易地构建独立、生产级别的基于Spring的应用程序。它提供了一种开箱即用的体验，...
Spring 核心技术（2）
Xuanyayo的博客
07-24 97
1.3 Bean概述 Spring IoC 容器管理一个或多个bean，他们都是根据提供的配置元数据（例如 XML 中定义）创建的。 在容器内部，这些 bean 定义以 BeanDefinition 对象进行表示，其中包含（以及其他信息）以下元数据： 包限定的类名：通常是 bean 的实际实现类 Bean 行为配置元素，定义 bean 在容器中的行为方式（范围，生命周期回调等） 引用 bean 执...
Spring学习-Spring核心技术（二）
weixin_43106572的博客
12-14 178
Spring容器-注解1. 注解简介2. 常用注解(1) @Required 由于注解比较常用且比较杂，单拎出来 1. 注解简介 通过在相关类、方法或字段声明上使用注解，将配置转移到组件类本身而不是在XML文件中。 注解 vs XML配置 注解：配置更短更简洁但是变得分散难以控制； XML：在擅长在不改动源码或者重新编译的情况下连接组件，相对复杂。 注解注入在XML注入之前执行，因此XML的配置会覆盖掉注解的注入。 <?xml version="1.0" encoding="UTF-8"?>
Spring核心技术（四）——Spring的依赖及其注入（续二）
weixin_30361641的博客
05-18 95
前面两篇文章描述了IoC容器中依赖的概念，包括依赖注入以及注入细节配置。本文将继续描述玩全部的依赖信息。 使用 depends-on 如果一个Bean是另一个Bean的依赖的话，通常来说这个Bean也就是另一个Bean的属性之一。多数情况下，开发者可以在配置XML元数据的时候使用<ref/>标签。然而，有时Bean之间的依赖关系不是直接关联的。比如：需要调用...
Spring（二）spring核心技术——ioc
krain的博客
07-16 252
一、Spring核心技术——IOC   IOC是Inversion of Control的缩写，即控制反转；是一种思想、理论、概念。IOC把对象的创建、管理、属性的赋值，都交给代码之外的容器实现，通过外部资源完成。使用ICO的目的就是在减少对代码改动的情况下，实现不同的功能，实现解耦合。 控制：创建对象，对象的属性赋值，对象之间的关系管理。 反转：把原来的开发人员管理，创建对象的权限转移给代码之外的容器实现。由容器代替开发人员管理对象。创建对象，给属性赋值。 正转：由开发人员在代码中，使用new
spring核心技术
weixin_44655181的博客
11-18 713
一 容器 容器是spring中最核心的部分，他管理着spring中bean的创建、配置和管理。 容器创建完bean后，通过DI依赖注入来实现不同bean之间的关系。 1容器的两种实现方式： BeanFactory 最基础的 ApplicationContext 基于BeanFactory实现，并实现应用框架级服务, 一般使用这种方式来进行加载容器 2 ApplicationContext的几种...
详解Spring的核心机制依赖注入
10-19
依赖注入是Spring框架最重要的设计理念之一，它是一种用于实现控制反转（Inversion of Control，简称IoC）的技术，旨在减少代码中的硬编码依赖并增强模块间的解耦。 首先，依赖注入是指一个对象对其他对象的依赖...
Spring Boot详解
04-08
Spring Boot详解 Spring框架自2003年发布以来，...以上内容涵盖了Spring Boot的基本概念、发展历程、核心特性及实战应用，旨在帮助读者全面理解Spring Boot的工作原理和使用方法，使其能够高效地开发Spring Boot应用。
Spring+SpringMVC+Mybatis SSM三大框架的运行流程、原理、核心技术详解
11-26
### Spring+SpringMVC+Mybatis SSM三大框架的运行流程、原理、核心技术详解 #### 一、Spring框架 **1. Spring的运行流程** - **第一步：加载配置文件** - 使用`ApplicationContext ac = new ...
Spring的核心技术
weixin_44362089的博客
10-01 760
国庆也要做个合格的舔狗，
Spring 核心技术
铠の魂博客
05-25 491
学习目录 Spring 的核心技术篇也是根据 Spring 官方文档进行翻译编写的，相当于翻译版 注意：本文不适合初学者观看，当然也可以进行参考 官方文档版本 Version 5.2.22.RELEASE 由于 Spring 核心篇幅过长，所以本文只记录 Spring 核心技术 的学习目录，用于快速定位 IoC 容器 ........................
Spring核心技术
gaofen100
02-04 142
Ch1. Spring概述 Spring为企业应用的开发提供了一个轻量级的解决方案，包括基于依赖注入的核心机制，基于AOP的声明式事务管理，与多种持久层技术的整合，以及优秀的Web MVC框架等。Spring支持对POJO（Plain Object Java Object，指最传统的Java对象，和任何模式都无关）的管理。 Spring的作者是Rod Johnson。Spring独立于应...
事务的四大特性
bihao8481的博客
08-27 156
本篇将讲诉数据库中事务的四大特性（ACID） 如果一个数据库声称支持事务的操作，那么该数据库必须要具备以下四个特性： ⑴ 原子性（Atomicity） 　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。 ⑵ 一致性（Consistency） 　　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。 　　拿转账来说，假设用户A和用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值