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编辑  收藏  举报

导航