Spring IOC
1 什么是ioc:ioc就是将对象的创建及对象之间的关系交给容器管理
2 BeanFactory与ApplicationContext,及FactoryBean
一般来说,我们称BeanFactory为ioc容器 而ApplicationContext成为Spring容器。
ApplicationContext主要的实现类是ClassPathXmlApplicationContext和FileSystemXmlApplicationContext,前者默认从类路径加载配置文件,后者默认从文件系统加载配置文件。
在获取ApplicationContext实例后,就可以像BeanFactory一样调用getBean(beanName)方法来获取bean了,ApplicationContext和BeanFactory初始化有一个重大区别:BeanFactory初始化容器时 并未实例化bean,直到第一次访问某个bean时才实例化目标bean,
而ApplicationContext 则在初始化应用上下文时就初始化所有单实例的bean,因此ApplicationContext的初始化时间要比BeanFactory的初始化长一些,后面要使用ApplicationContext的bean时 可以直接去缓存中获取bean。
FactoryBean是一种特殊的bean接口,其作用也是创建bean,包含FactoryBean<T> 包含三个方法
boolean isSingleton(); 返回所创建的bean是否是单例的,
T getObject() 返回又FactoryBean所创建的bean实例,如果isSingleton方法返回true,那么bean实例将会被放到spring容器的缓存池中,
Class<?> getObejctType();返回创建bean的类型。
当一个需要被注入到容器的bean实现了FactoryBean接口时,通过getBean()方法返回的不是FactoryBean本身,而是FactoryBean.getObject()返回的对象,也就是说FactoryBean.getObject()代理了getBean()方法。
3 Bean的生命周期
BeanFactory中的bean的生命周期
package com.bujiang.magic; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.beans.factory.BeanNameAware; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; public class Car implements BeanFactoryAware ,BeanNameAware,InitializingBean,DisposableBean{ private String brand; private String color; private int maxSpeed; private BeanFactory beanFactory; private String beanName; public Car() { System.out.println("调用Car的构造方法"); } public String getBrand() { return brand; } public void setBrand(String brand) { System.out.println("调用setBrand() 方法"); this.brand = brand; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public int getMaxSpeed() { return maxSpeed; } public void setMaxSpeed(int maxSpeed) { this.maxSpeed = maxSpeed; } public BeanFactory getBeanFactory() { return beanFactory; } public void setBeanFactory(BeanFactory beanFactory) { System.out.println("调用BeanFactoryAware的setBeanFactory方法"); this.beanFactory = beanFactory; } public String getBeanName() { return beanName; } public void setBeanName(String beanName) { System.out.println("调用BeanNameAware的setBeanName方法"); this.beanName = beanName; } @Override public void destroy() throws Exception { System.out.println("调用DisposableBean的destroy方法"); } @Override public void afterPropertiesSet() throws Exception { System.out.println("调用InitializingBean的afterPropertiesSet方法"); } public void myInit() { System.out.println("调用car的init-method指向的myInit方法"); } public void myDestroy() { System.out.println("调用car的destroy-method指向的myDestroy方法"); } @Override public String toString() { return "Car [brand=" + brand + ", color=" + color + ", maxSpeed=" + maxSpeed + ", beanFactory=" + beanFactory + ", beanName=" + beanName + "]"; } }
package com.bujiang.magic; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; public class MyBeanPostProcessor implements BeanPostProcessor{ public Object postProcessBeforeInitialization(Object bean,String beanName)throws BeansException { if(beanName.equals("car")) { Car car = (Car)bean; if(car.getColor()==null) { System.out.println("调用MyBeanPostProcessor的postProcessBeforeInitialization方法,为bean设置属性color,为黑黑黑"); car.setColor("黑黑黑"); } } return bean; } public Object postProcessAfterInitialization(Object bean,String beanName)throws BeansException { if(beanName.equals("car")) { Car car = (Car)bean; if(car.getMaxSpeed()>=200) { System.out.println("调用MyBeanPostProcessor的postProcessAfterInitialization方法,为bean设置属性MaxSpeed,为999"); car.setMaxSpeed(999); } } return bean; } }
package com.bujiang.magic; import java.beans.PropertyDescriptor; import org.springframework.beans.BeansException; import org.springframework.beans.PropertyValues; import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor; public class MyInsttabtiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{ public Object postProcessBeforeInstantiation(Class beanClass,String beanName) throws BeansException { if("car".equals(beanName)) { System.out.println("调用MyInsttabtiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法"); } return null; } public boolean postProcessAfterInstantiation(Object bean,String beanName) throws BeansException { if("car".equals(beanName)) { System.out.println("调用MyInsttabtiationAwareBeanPostProcessor的postProcessAfterInstantiation方法"); } return true; } public PropertyValues postProcessPropertyValues(PropertyValues pvs,PropertyDescriptor[] pds,Object bean,String beanName)throws BeansException { if("car".equals(beanName)) { System.out.println("调用MyInsttabtiationAwareBeanPostProcessor的postProcessPropertyValues方法"); } return pvs; } }
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd" default-autowire="byName"> <bean id="car" class="com.bujiang.magic.Car" init-method="myInit" destroy-method="myDestroy" p:brand="红旗CA72" p:maxSpeed="200" scope="singleton" /> <!-- <bean id="car" class="com.bujiang.magic.Car" init-method="myInit" destroy-method="myDestroy" p:brand="红旗CA72" p:maxSpeed="200" scope="prototype" /> --> </beans>
package com.bujiang.magic; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.config.ConfigurableBeanFactory; import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.beans.factory.xml.XmlBeanDefinitionReader; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; public class BeanLifeCycle { private static void lifeTest() { //加载配置文件并启动容器 Resource res = new ClassPathResource("com/bujiang/magic/beans.xml"); BeanFactory bf = new DefaultListableBeanFactory(); XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory)bf); reader.loadBeanDefinitions(res); //向容器注册MyBeanPostProcessor后置处理器,如果容器不注册那么BeanPostProcessor所有的方法都不执行 ((ConfigurableBeanFactory) bf).addBeanPostProcessor(new MyBeanPostProcessor()); //向容器注册MyInsttabtiationAwareBeanPostProcessor后置处理器,如果容器不注册那么InstantiationAwareBeanPostProcessor所有的方法都不执行 ((ConfigurableBeanFactory) bf).addBeanPostProcessor(new MyInsttabtiationAwareBeanPostProcessor()); //第一次从容器中获取bean对象,将触发实例化bean的生命周期方法的调用 Car car1 = (Car) bf.getBean("car"); System.out.println(car1.toString()); car1.setColor("红色"); //第二次从容器中获取bean,直接从缓存中获取,不会触发生命周期方法 Car car2 = (Car) bf.getBean("car"); System.out.println("car1=car2?"+(car1==car2)); //关闭容器 ((DefaultListableBeanFactory)bf).destroySingletons(); } public static void main(String[] args) { lifeTest(); } }
输出结果
调用MyInsttabtiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法 调用Car的构造方法 调用MyInsttabtiationAwareBeanPostProcessor的postProcessAfterInstantiation方法 调用MyInsttabtiationAwareBeanPostProcessor的postProcessPropertyValues方法 调用setBrand() 方法 调用BeanNameAware的setBeanName方法 调用BeanFactoryAware的setBeanFactory方法 调用MyBeanPostProcessor的postProcessBeforeInitialization方法,为bean设置属性color,为黑黑黑 调用InitializingBean的afterPropertiesSet方法 调用car的init-method指向的myInit方法 调用MyBeanPostProcessor的postProcessAfterInitialization方法,为bean设置属性MaxSpeed,为999 Car [brand=红旗CA72, color=黑黑黑, maxSpeed=999, beanFactory=org.springframework.beans.factory.support.DefaultListableBeanFactory@11c20519: defining beans [car]; root of factory hierarchy, beanName=car] car1=car2?true 调用DisposableBean的destroy方法 调用car的destroy-method指向的myDestroy方法
当通过getBean获取bean时:
1 调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation()方法
2 调用调用构造函数或者其他方式实例化bean
3 调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInstantiation()方法
4 调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues()方法
5 调用bean的设置属性值的方法 setXXX()
6 调用BeanFactoryAware的setBeanName()方法
7 调用BeanFactoryAware的setBeanFactory()方法
8 调用BeanPostProcessor的postProcessBeforeInitialization方法
9 调用InitializingBean的afterPropertiesSet方法
10 调用bean指定的init-method方法
11 调用BeanPostProcessor的postProcessAfterInitialization方法
12如果bean的作用范围是多例(prototype),那么将bean返回给调用者 Spring不再管理这个bean的生命周期,如果是单例(singleton) 则将bean放入到ioc容器的缓存池中,并将bean的引用返回给调用者,ioc容器继续管理这个bean的生命周期
13 当容器关闭时,触发DisposableBean的destroy方法
14 执行bean的destroy-method指定的方法。
以上方法可以分为以下4类
1 Bean自身的方法:如构造方法,setXXX方法 init-method指定的方法 destroy-method指定的方法
2 Bean级别生命周期接口方法: BeanFactoryAware ,BeanNameAware,InitializingBean,DisposableBean接口方法,执行方法由bean类直接实现
3 容器级别的生命周期方法:如BeanPostProcessor,InstantiationAwareBeanPostProcessor的方法,这些方法一般成为类的后置处理器,当IOC容器创建任何bean的时候,这些后置处理器都会起作用,就是说这些处理器的影响是全局性的
4 工厂后处理器接口方法,工厂后处理器也是容器级的,在应用上下文装配配置文件后立即调用
ApplicationContext中的bean的生命周期
bean在ApplicationContext的生命周期与在BeanFactory中的生命周期类似,不同的是如果bean 实现了ApplicationContextAware接口,则会增加该接口的setApplicationContext方法,该方法在上面生命周期的第七步之后,第八步之前。ApplicationContext与BeanFactory的另外一个最大的不同是 前者会利用java反射机制自动识别配置文件中定义的工厂后置处理器,并自动将他们注册到上下文,而后者需要手动的addBeanPostProcessor方法才行,因此应用开发中普遍使用ApplicationContext而不是BeanFactory。如果配置文件定义了多个工厂后置处理器,那么让它们实现import org.springframework.core.Ordered接口,如果不实现这个接口那么,那么的先后顺序将由它们在xml中定义的位置确定,先定义的先执行。
IOC装配bean
Spring启动时读取应用程序提供的bean的配置信息,并在容器中生成一份相应的bean注册表,然后根据注册表实例化bean,装配好bean之间的依赖关系,为应用提供运行环境。Bean的配置信息就是bean的元数据信息,元数据信息在容器内部对应的是一个个BeanDefinition形成的注册表,Spring通过元数据和外部bean定义实现解耦。
依赖注入,spring支持两种依赖注入的方式(属性注入和构造函数注入),此外 还支持工厂方法注入。
属性注入,属性注入是通过setXXX方法将bean的属性或者依赖的对象注入到bean中,属性注入比较于构造器注入是更灵活的。属性注入要求Bean提供一个默认的无参构造函数,并且要注入的属性提供setXXX方法,Spring先利用构造方法实例化Bean对象,然后利用反射方式调用Setter方法注入属性值。使用属性注入时,Spring 只会检查bean中是否有对应的setter方法,至于Bean中是否有这个属性则不做要求,对于属性注入时的属性名,spring希望变量前两个字母要么全部大写,要么全部小写,如brand,IDCode是合法的,而iC,iDCard是不合法的,当我们使用不合法的属性名,启动Spring 会报Invalid property 'iDCard' of bean class,
构造函数注入,相较与属性注入,构造函数注入比较繁琐,这里不做介绍
工厂方法注入
1 静态工厂方法注入
<bean id = "carFactory" class="xxxx.CarFactory"></bean> <!-- 由于普通工厂方法是非静态的,所以需要先实例化工厂类 --> <bean id="car" factory-bean="carFactory" factory-method="createCar"></bean>
2 静态工厂方法注入
<!-- 由于普通工厂方法是静态的,所以可以直使用方法方法注入 --> <bean id="car" factory-method="xxx.CarFactory。createCar"></bean>
Bean的作用域
singleton
传统开发中,由于dao类中持有Connection这个非现场安全的变量,因此往往是不能采用单例模式的,但是spring 利用aop和ThreadLocal 对非线程安全的变量进行了特殊的处理(这个后面再说),使这些变成了线程安全的类,这哥原因也是为什么大部分bean都能以单例模式运行的原因。
prototype
这种是非单例的模式,spring容器将这种bean初始化之后交给调用者,其后续的生命周期spring不再管理。
其他作用域 request,session,gloalSession 这些与WebApplicationContext相关的作用域
注解
@Component 等价于一下注解配置
<bean id = "carFactory" class="xxxx.CarFactory"></bean>
此外spring还提供一下三个注解,功能等价于@Component ,作用仅仅是表名各个层中的bean的用途意义,完全可以用@Component替代他们
@Respository,@Service ,@Controller。
@Autowired 自动装配,默认使用byType方式,按照类型匹配来注入bean。@Autowired 支持在属性和方法上使用,作用都是自动注入。
@Resource ,@Inject ,这两者与@Autowired 作用基本一致,@Resource是byName注入,@Inject 用的比较少
@Qualifier 指定注入bean的名称。、
基于java类的注解配置
@Configuration 这个注解的作用是将一个pojo标注为spring配置类,
@Bean 这个注解是返回一个bean,bean的名称默认是方法名,
posted on 2019-01-07 17:39 Advance_Man 阅读(187) 评论(0) 编辑 收藏 举报