文章参考自: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功能。