day05-Spring管理Bean-IOC-03
Spring管理Bean-IOC-03
2.基于XML配置bean
2.15bean的生命周期
bean对象的创建是由JVM完成的，然后执行如下方法：
- 执行构造器
- 执行set相关方法
- 调用bean的初始化方法（需要配置）
- 使用bean
- 当容器关闭时，调用bean的销毁方法（需要配置）
例子
House：
package com.li.bean;
/**
* @author 李
* @version 1.0
*/
public class House {
private String name;
public House() {
System.out.println("House() 构造器被执行...");
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("House setName()=" + name);
this.name = name;
}
//说明：初始化方法是自定义的，名字随意，只要配置的时候指定名称就行了
public void init() {
System.out.println("House init() 被执行...");
}
//说明：销毁的方法是也自定义的，名字随意
public void destroy() {
System.out.println("House destroy() 被执行...");
}
}
beans.xml：
<!--配置House对象，演示bean的生命周期
1.init-method 指定bean的初始化方法，该方法在bean执行setter方法后执行
2.init-method指定方法执行的时机，由spring容器来控制
3.destroy-method 指定bean的销毁方法，该方法在容器关闭的时候被执行
4.destroy-method指定方法执行的时机，也是由spring容器来控制
-->
<bean class="com.li.bean.House" id="house"
init-method="init"
destroy-method="destroy">
<property name="name" value="北京大豪宅"/>
</bean>
测试方法：
//测试bean的生命周期
@Test
public void testBeanLife() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
House house = ioc.getBean("house", House.class);
System.out.println("使用house=" + house);
//关闭容器
// 1.ioc的编译类型 ApplicationContext ，运行类型 ClassPathXmlApplicationContext
// 2.因为 ClassPathXmlApplicationContext 实现了接口 ConfigurableApplicationContext
// 3.而ConfigurableApplicationContext接口有 close方法
// 4.因此将ioc转成 ConfigurableApplicationContext 类型，调用close方法，关闭容器
((ConfigurableApplicationContext)ioc).close();
}
使用细节：
- 初始化方法和销毁方法由程序员自定义（包括方法名称，在配置bean的时候指定即可）
- 销毁方法只有当关闭容器时才会被调用
2.16配置bean的后置处理器
- 在spring的ioc容器，可以配置bean的后置处理器（后置处理器其实就是一个java对象）
- 该处理器会在bean 初始化方法调用前 和 初始化方法调用后 被调用
- 程序员可以在后置处理器中编写自己的业务代码
例子
1.House类（见2.15），该方法设置了构造函数，bean初始化方法等
2.创建后置处理器MyBeanPostProcessor：
后置处理器需要实现BeanPostProcessor接口，该接口中有两个重要的方法，对应我们之前说的 “初始化方法调用前和初始化方法调用后被调用”
package com.li.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* @author 李
* @version 1.0
* 这是一个后置处理器，必须实现接口 BeanPostProcessor
*/
public class MyBeanPostProcessor implements BeanPostProcessor {
/**
* 调用时机：在Bean初始化方法前被调用（bean没有配置初始化方法，此方法也会被调用）
*
* @param bean 传入 在IOC容器中创建/配置的Bean
* @param beanName 在IOC容器中创建/配置的Bean的id
* @return Object 返回 bean（返回前程序员可以对bean进行修改/处理，再返回）
* @throws BeansException
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization()被调用..." +
"bean=" + bean + " beanName=" + beanName);
return bean;
}
/**
* 调用时机：在Bean初始化方法后被调用（bean没有配置初始化方法，此方法也会被调用）
*
* @param bean 传入 在IOC容器中创建/配置的Bean
* @param beanName 在IOC容器中创建/配置的Bean的id
* @return Object 返回 bean（返回前程序员可以对bean进行修改/处理，再返回）
* @throws BeansException
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization()被调用..." +
"bean=" + bean + " beanName=" + beanName);
return bean;
}
}
3.beans02.xml：
因为后置处理器对象会作用在容器配置文件的所有bean对象中，因此这里新创建一个容器文件beans02.xml，为了输出干净，该配置文件中只配置了house一个bean对象
<!--配置House对象-->
<bean class="com.li.bean.House" id="house"
init-method="init" destroy-method="destroy">
<property name="name" value="海景大豪宅"/>
</bean>
<!--配置后置处理器对象
1.当我们在beans02.xml容器配置文件 配置了MyBeanPostProcessor后
2.该后置处理器对象，就会作用在该容器文件的所有Bean对象中
-->
<bean class="com.li.bean.MyBeanPostProcessor" id="myBeanPostProcessor"/>
4.测试方法：
//测试bean的后置处理器
@Test
public void testBeanPostProcessor() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans02.xml");
House house = ioc.getBean("house", House.class);
System.out.println("使用house=" + house);
//关闭容器
((ClassPathXmlApplicationContext)ioc).close();
}
输出如下：postProcessBeforeInitialization()和postProcessAfterInitialization()方法分别在bean的初始化方法前后调用
细节说明：
- 怎么执行到这个方法？==>使用AOP（反射+动态代理+IO+容器+注解）
- 有什么用？==>可以对IOC容器中所有对象进行统一处理，如：日志处理/权限校验/安全的验证/事务管理
- 针对容器的所有对象吗？ 是的==>切面编程特点
后置处理器是一个比较难理解的知识点，后面会实现这个机制，深入理解
2.17通过属性文件给bean注入值
在spring的ioc容器中，可以通过属性文件给bean注入值
例子
1.在src目录下创建my.properties文件
monsterId=1000
name=jack
skill=hello
2.在beans.xml中配置：
使用配置文件的方式需要引入命名空间：
<!--指定属性文件
1.注意要引入命名空间才能使用
2.location="classpath:my.properties" 表示指定属性文件的位置
（注意需要带上"classpath"）
3.这时我们的属性值通过${属性名} 获取
4.这里的属性名就是my.properties中的 key
-->
<context:property-placeholder location="classpath:my.properties"/>
<!--配置Monster对象
通过属性文件给Monster对象赋值-->
<bean class="com.li.bean.Monster" id="monster1000">
<property name="monsterId" value="${monsterId}"/>
<property name="name" value="${name}"/>
<property name="skill" value="${skill}"/>
</bean>
3.测试：
//通过属性文件给bean属性赋值
@Test
public void setBeanByFile() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster monster1000 = ioc.getBean("monster1000", Monster.class);
System.out.println("monster1000=" + monster1000);
}
注意：如果properties文件中的value是中文，会出现乱码，需要将中文转为unicode编码：
2.18基于XML的bean自动装配
在spring的ioc容器中，可以实现自动装配bean
例子
1.OrderDAO
package com.li.dao;
/**
* @author 李
* @version 1.0
* 这是一个DAO类
*/
public class OrderDAO {
public void saveOrder() {
System.out.println("保存一个订单...");
}
}
2.OrderService
package com.li.service;
import com.li.dao.OrderDAO;
/**
* @author 李
* @version 1.0
* 这是一个Service类
*/
public class OrderService {
//OrderDAO属性
private OrderDAO orderDAO;
//getter
public OrderDAO getOrderDAO() {
return orderDAO;
}
//setter
public void setOrderDAO(OrderDAO orderDAO) {
this.orderDAO = orderDAO;
}
}
3.OrderServlet：
package com.li.web;
import com.li.service.OrderService;
/**
* @author 李
* @version 1.0
* Servlet即 Controller
*/
public class OrderServlet {
//属性OrderService
private OrderService orderService;
//getter
public OrderService getOrderService() {
return orderService;
}
//setter
public void setOrderService(OrderService orderService) {
this.orderService = orderService;
}
}
4.beans.xml：
- autowire="byType"方式
<!--配置OrderDAO对象-->
<bean class="com.li.dao.OrderDAO" id="orderDAO"/>
<!--配置OrderService对象
1. 属性 autowire="byType" 表示在创建OrderService时，
通过类型的方式，给对象的属性自动完成赋值/引用
2. 比如OrderService对象有private OrderDAO属性，就会在容器中找有没有OrderDAO类型的对象
如果有，就会自动进行装配（按照类型的方式来装配时，那么该容器中不能有超过一个OrderService对象）
-->
<bean autowire="byType" class="com.li.service.OrderService" id="orderService"/>
<!--配置OrderServlet对象，同理-->
<bean autowire="byType" class="com.li.web.OrderServlet" id="orderServlet"/>
- 使用autowire="byName"方式
<!--配置OrderDAO对象-->
<bean class="com.li.dao.OrderDAO" id="orderDAO"/>
<!--配置OrderService对象
3.如果设置的是 autowire="byName" 表示通过名字完成自动装配
比如下面的 autowire=" byName" class="com.li.service.OrderService"
（1）spring会按照 OrderService对象的属性（如orderDAO）
（2）找到这个属性的setXxx()方法的Xxx名称，在容器中找到相同id的对象来进行自动装配
（3）例如我们的orderService对象中有一个setOrderDAO()，就会找id="orderDAO"的对象来进行自动装配
（4）如果没有就装配失败
-->
<bean autowire="byName" class="com.li.service.OrderService" id="orderService"/>
<!--配置OrderServlet对象，同理-->
<bean autowire="byName" class="com.li.web.OrderServlet" id="orderServlet"/>
注意：autowire="byName"不是通过对象属性名来找到要自动装配的对象的，而是通过setXxx方法的名称来找，因为底层是反射实现的。因此如果对象的属性的setXxx方法的名称改变了，被自动装配的对象id也要随之改变
5.测试类：
//基于XML的bean自动装配
@Test
public void setBeanByAutowire() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
OrderServlet orderServlet = ioc.getBean("orderServlet", OrderServlet.class);
//验证是否自动装配上了OrderService
System.out.println(orderServlet.getOrderService());
//验证是否自动装配上了OrderDAO
System.out.println(orderServlet.getOrderService().getOrderDAO());
}
可以看到orderServlet的orderService属性，以及属性的属性orderDAO成功装载了:（autowire="byType"/"byName"方式）
2.19Spring EL表达式
非重点，了解即可
- Spring Expression Language，Spring表达式语言，简称SpEL。支持运行时查询并可以操作对象。
- 和 JSP的EL表达式一样，SpEL根据Javabean风格的getXxx()、setXxx()方法定义的属性访问对象
- SpEL使用
#{}作为定界符，所有在大括号中的字符都将被认为是SpEL表达式
应用实例
SpELBean：
package com.li.bean;
/**
* @author 李
* @version 1.0
*/
public class SpELBean {
private String name;
private Monster monster;
private String monsterName;
private String crySound;
private String bookName;
private Double result;
public SpELBean() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Monster getMonster() {
return monster;
}
public void setMonster(Monster monster) {
this.monster = monster;
}
public String getMonsterName() {
return monsterName;
}
public void setMonsterName(String monsterName) {
this.monsterName = monsterName;
}
public String getCrySound() {
return crySound;
}
public void setCrySound(String crySound) {
this.crySound = crySound;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public Double getResult() {
return result;
}
public void setResult(Double result) {
this.result = result;
}
//cry方法返回字符串
public String cry(String sound){
return "发出"+sound+"的叫声";
}
//read方法返回字符串
public static String read(String bookName){
return "正在看"+bookName;
}
@Override
public String toString() {
return "SpELBean{" +
"name='" + name + '\'' +
", monster=" + monster +
", monsterName='" + monsterName + '\'' +
", crySound='" + crySound + '\'' +
", bookName='" + bookName + '\'' +
", result=" + result +
'}';
}
}
配置beans03.xml：
<!--配置一个Monster对象-->
<bean class="com.li.bean.Monster" id="monster01">
<property name="monsterId" value="100"/>
<property name="name" value="蜈蚣精"/>
<property name="skill" value="蜇人"/>
</bean>
<!--spring el 表达式使用-通过sp el给bean的属性赋值-->
<bean class="com.li.bean.SpELBean" id="spELBean">
<!--sp el 给字面量-->
<property name="name" value="#{'一只猫猫'}"/>
<!--sp el 引用其他 bean（该bean要存在）-->
<property name="monster" value="#{monster01}"/>
<!--sp el 引用其他 bean 的属性值-->
<property name="monsterName" value="#{monster01.name}"/>
<!--sp el 调用普通方法，将该方法的返回值赋给 bean对象的属性-->
<property name="crySound" value="#{spELBean.cry('喵喵喵')}"/>
<!--sp el 调用静态方法，将该方法的返回值赋给 bean对象的属性
注意：需要写上类全路径-->
<property name="bookName" value="#{T(com.li.bean.SpELBean).read('红楼梦')}"/>
<!--sp el 通过运算赋值-->
<property name="result" value="#{89*1.0+33/3}"/>
</bean>
测试类：
//通过spring el 对属性赋值
@Test
public void setBeanBySpel() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
SpELBean spELBean = ioc.getBean("spELBean", SpELBean.class);
System.out.println(spELBean);
}
