精华内容
下载资源
问答
  • 本篇文章主要介绍了详解Spring中bean生命周期回调方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 创建Bean的入口:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean。 实例化 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#...

    在这里插入图片描述

    创建Bean的入口:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean。

    实例化

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    	// Make sure bean class is actually resolved at this point.
    	Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
    		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    	}
    
    	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    	if (instanceSupplier != null) {
    		return obtainFromSupplier(instanceSupplier, beanName);
    	}
    
    	// 如果factory-method属性不为空,则使用factory-method方式实例化
    	if (mbd.getFactoryMethodName() != null) {
    		return instantiateUsingFactoryMethod(beanName, mbd, args);
    	}
    
    	// Shortcut when re-creating the same bean...
    	boolean resolved = false;
    	boolean autowireNecessary = false;
    	if (args == null) {
    		synchronized (mbd.constructorArgumentLock) {
    			if (mbd.resolvedConstructorOrFactoryMethod != null) {
    				resolved = true;
    				autowireNecessary = mbd.constructorArgumentsResolved;
    			}
    		}
    	}
    	if (resolved) {
    		if (autowireNecessary) {
    			return autowireConstructor(beanName, mbd, null, null);
    		}
    		else {
    			return instantiateBean(beanName, mbd);
    		}
    	}
    
    	// Candidate constructors for autowiring?
    	// 找到构造方法
    	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
    		return autowireConstructor(beanName, mbd, ctors, args);
    	}
    
    	// Preferred constructors for default construction?
    	ctors = mbd.getPreferredConstructors();
    	if (ctors != null) {
    		// 构造器注入
    		return autowireConstructor(beanName, mbd, ctors, null);
    	}
    
    	// No special handling: simply use no-arg constructor.
    	// 使用默认的构造方法实例化
    	return instantiateBean(beanName, mbd);
    }
    

    如果BeanDefinition的factory-method属性不为空,那么使用factory-method的实例化过程。

    设置属性

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    	... ...
    	if (hasInstAwareBpps) {
    		if (pvs == null) {
    			pvs = mbd.getPropertyValues();
    		}
    		for (BeanPostProcessor bp : getBeanPostProcessors()) {
    			if (bp instanceof InstantiationAwareBeanPostProcessor) {
    				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    				// 调用各个BeanPostProcessor.postProcessProperties对属性进行设置
    				/**
    				 * AutowiredAnnotationBeanPostProcessor处理@Autowired
    				 * CommonAnnotationBeanPostProcessor处理@Resource
    				 *
    				 * @see AutowiredAnnotationBeanPostProcessor#postProcessProperties(org.springframework.beans.PropertyValues, java.lang.Object, java.lang.String)
    				 * @see org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#postProcessProperties(org.springframework.beans.PropertyValues, java.lang.Object, java.lang.String)
    				 */
    				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
    				
    	... ...
    }
    

    初始化

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean

    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    	if (System.getSecurityManager() != null) {
    		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    			invokeAwareMethods(beanName, bean);
    			return null;
    		}, getAccessControlContext());
    	}
    	else {
    		// 调用aware方法
    		// BeanNameAware/BeanClassLoaderAware/BeanFactoryAware对应的setXxx方法
    		invokeAwareMethods(beanName, bean);
    	}
    
    	Object wrappedBean = bean;
    	if (mbd == null || !mbd.isSynthetic()) {
    		// 处理EnvironmentAware/EmbeddedValueResolverAware/ResourceLoaderAware/
    		// ApplicationEventPublisherAware/MessageSourceAware/ApplicationContextAware
    		// 处理@PostConstruct
    		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    	}
    
    	try {
    		// InitializingBean.afterPropertiesSet()
    		// 调用init-method
    		invokeInitMethods(beanName, wrappedBean, mbd);
    	}
    	catch (Throwable ex) {
    		throw new BeanCreationException(
    				(mbd != null ? mbd.getResourceDescription() : null),
    				beanName, "Invocation of init method failed", ex);
    	}
    	if (mbd == null || !mbd.isSynthetic()) {
    		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    	}
    
    	return wrappedBean;
    }
    

    factory-method的实例化过程

    spring中可以使用factory-method向容器中注入实例。

    使用另一个类的实例方法注入

    package com.morris.spring.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    
    @Data
    public class Boy {
    
    	private String name;
    	
    	public Boy(String name) {
    		this.name = name;
    	}
    }
    
    package com.morris.spring.service;
    
    import com.morris.spring.entity.Boy;
    
    public class BoyService {
    
    	public Boy newInstance() {
    		return new Boy("morris");
    	}
    
    }
    
    <bean id="boyService" class="com.morris.spring.service.BoyService"/>
    <bean id="boy" factory-bean="boyService" factory-method="newInstance"/>
    

    使用本类的静态方法实例化

    package com.morris.spring.entity;
    
    import lombok.Data;
    
    @Data
    public class Boy {
    
    	private String name;
    
    	public Boy(String name) {
    		this.name = name;
    	}
    
    	public static Boy newInstance() {
    		return new Boy("bob");
    	}
    
    }
    
    <bean id="boy2" class="com.morris.spring.entity.Boy" factory-method="newInstance"/>
    

    源码分析

    org.springframework.beans.factory.support.ConstructorResolver#instantiateUsingFactoryMethod

    public BeanWrapper instantiateUsingFactoryMethod(
    		String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    
    	BeanWrapperImpl bw = new BeanWrapperImpl();
    	this.beanFactory.initBeanWrapper(bw);
    
    	Object factoryBean;
    	Class<?> factoryClass;
    	boolean isStatic;
    
    	String factoryBeanName = mbd.getFactoryBeanName();
    	if (factoryBeanName != null) {
    		// factoryBeanName不为空说明使用的是另一个类的实例方法来创建实例
    		if (factoryBeanName.equals(beanName)) {
    			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
    					"factory-bean reference points back to the same bean definition");
    		}
    		// 根据factoryBeanName获取另一个类的实例
    		factoryBean = this.beanFactory.getBean(factoryBeanName);
    		if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
    			throw new ImplicitlyAppearedSingletonException();
    		}
    		this.beanFactory.registerDependentBean(factoryBeanName, beanName);
    		factoryClass = factoryBean.getClass();
    		isStatic = false; // 非静态
    	}
    	else {
    		// factoryBeanName为空说明使用的是本类的静态方法来创建实例
    		// It's a static factory method on the bean class.
    		if (!mbd.hasBeanClass()) {
    			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
    					"bean definition declares neither a bean class nor a factory-bean reference");
    		}
    		factoryBean = null;
    		factoryClass = mbd.getBeanClass();
    		isStatic = true; // 静态
    	}
    
    	Method factoryMethodToUse = null;
    	ArgumentsHolder argsHolderToUse = null;
    	Object[] argsToUse = null;
    
    	if (explicitArgs != null) {
    		argsToUse = explicitArgs;
    	}
    	else {
    		Object[] argsToResolve = null;
    		synchronized (mbd.constructorArgumentLock) {
    			factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
    			if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
    				// Found a cached factory method...
    				argsToUse = mbd.resolvedConstructorArguments;
    				if (argsToUse == null) {
    					argsToResolve = mbd.preparedConstructorArguments;
    				}
    			}
    		}
    		if (argsToResolve != null) {
    			argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
    		}
    	}
    
    	if (factoryMethodToUse == null || argsToUse == null) {
    		// Need to determine the factory method...
    		// Try all methods with this name to see if they match the given arguments.
    		factoryClass = ClassUtils.getUserClass(factoryClass);
    
    		List<Method> candidates = null;
    		if (mbd.isFactoryMethodUnique) {
    			if (factoryMethodToUse == null) {
    				factoryMethodToUse = mbd.getResolvedFactoryMethod();
    			}
    			if (factoryMethodToUse != null) {
    				candidates = Collections.singletonList(factoryMethodToUse);
    			}
    		}
    		if (candidates == null) {
    			candidates = new ArrayList<>();
    			Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
    			for (Method candidate : rawCandidates) {
    				// 找到factory-method方法
    				if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
    					candidates.add(candidate);
    				}
    			}
    		}
    
    		if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
    			Method uniqueCandidate = candidates.get(0);
    			if (uniqueCandidate.getParameterCount() == 0) {
    				mbd.factoryMethodToIntrospect = uniqueCandidate;
    				synchronized (mbd.constructorArgumentLock) {
    					mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
    					mbd.constructorArgumentsResolved = true;
    					mbd.resolvedConstructorArguments = EMPTY_ARGS;
    				}
    				// 调用factory-method方法进行实例化
    				bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
    				return bw;
    			}
    		}
    ... ...
    
    展开全文
  • Spring中bean生命周期(浅显易懂)

    千次阅读 2018-08-02 19:53:21
    1、网上下的图,以供参考 2、/**  * 创建一个测试类的UserService  * @author lion  *  */ public class UserService {  private String username;... * 以下方法为了方便测试、bean生命周期过程的执...

    1、网上下的图,以供参考

    2、
    /**
     * 创建一个测试类的UserService
     * @author lion
     *
     */

    public class UserService {
        private String username;//用户名
        private String password;//密码
        /**
         * 以下方法为了方便测试、bean生命周期过程的执行顺序,事先打乱方法输出顺序
         */
        public void destroy(){
            System.out.println("---destory方法 -----");
        }
        public void init(){
            System.out.println("---初始化方法 -----");
        }
        public UserService(){
            System.out.println("---构造方法 -----");
        }
        public void setUsername(String username) {
            this.username = username;
            System.out.println("---setName方法-----");
        }
     
    }

     

    /**
     * 创建一个 TestUserServlet类
     */

    @WebServlet("/TestUserServlet")
    public class TestUserServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
           
        public TestUserServlet() {
            super();    
        }
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            doPost(request, response);
        }
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
             WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
             UserService userService =(UserService) wac.getBean("userservice");//调用userService这个bean,查看打印输
        }
    }
     

    3、配置文件

    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
            http://www.springframework.org/schema/mvc 
            http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-3.2.xsd 
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-3.2.xsd " >
        <!--注意测试生命周期的时候,需要配置init-method,destroy-method-->
        <bean id="userservice" class="cn.web.neusoft.service.UserService" init-method="init" destroy-method="destroy">
                <property name="username" value="pyc" /> 
                <property name="password" value="123" /> 
        </bean>
       
    </beans>
     

    打印输出结果:

    ------参考输出信息,可以看出bean的生命周期几个重要方法的执行顺序---------------------------

    --------构造方法---------

    ---------setName方法-----------------

    ---------init方法----------------------(由init-method属性指定)

    //如果有功能方法 如login(),输出在初始化方法init()方法后

    ---------destory方法---------------    (销毁方法)

    以上大家可以测试一下,我试过没问题。

     

    展开全文
  • 销毁 的过程,bean生命周期由容器进行管理,我们可以自定义bean的初始化和销毁方法来满足我们的需求,当容器在bean进行到当前生命周期的时候,来调用自定义的初始化和销毁方法。今天主要讲解如何定义初始化和销毁...

    最近在重新学习spring优秀的框架,顺便记录一下自己的总结,同时分享给大家。bean的生命周期指的是:bean创建-->初始化-->销毁 的过程,bean的生命周期由容器进行管理,我们可以自定义bean的初始化和销毁方法来满足我们的需求,当容器在bean进行到当前生命周期的时候,来调用自定义的初始化和销毁方法。今天主要讲解如何定义初始化和销毁的4中方法。

    1,使用initMethod和destroyMethod

    下面代码全部是通过配置类,而不是配置xml文件

    Train.java

    package cap5.bean;
    
    public class Train {
    
    	public Train() {
    		// TODO Auto-generated constructor stub
    		super();
    		System.out.println("Train创建");
    	}
    	
    	public void init() {
    		System.out.println("train init...");
    	}
    	
    	public void destroy() {
    		System.out.println("train destroy");
    	}
    }

    MainConfig.java

    package cap5.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.context.annotation.ComponentScan.Filter;
    
    import cap5.bean.Bike;
    import cap5.bean.Jeep;
    import cap5.bean.TaolongBeanPostProcessor;
    import cap5.bean.Train;
    //@ComponentScan(value= {"cap5.bean"},includeFilters= {@Filter(type=FilterType.ASSIGNABLE_TYPE,classes=TaolongBeanPostProcessor.class)})
    @Configuration
    public class MainConfig {
    
    	@Bean(initMethod="init",destroyMethod="destroy")
    	public Train train() {
    		return new Train();
    	}
    	
    	/*@Bean
    	public Bike bike() {
    		return new Bike();
    	}*/
    	
    	/*@Bean
    	public Jeep jeep() {
    		return new Jeep();
    	}*/
    }

    MainTest.java

    package cap5.test;
    
    import org.junit.Test;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import cap5.config.MainConfig;
    
    public class MainTest {
    
    	@Test
    	public void test() {
    		AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
    		
    		System.out.println("IOC 容器创建完成");
    		System.out.println("IOC 容易准备关闭");
    		/*String[] names = app.getBeanDefinitionNames();
    		for(String name:names) {
    			System.out.println("name="+name);
    		}*/
    		app.close();
    		
    	}
    }

    打印结果: 

    2,让bean实现InitializingBean和DisposableBean接口,然后分别实现afterPropertiesSet()方法和destroy()方法

    afterPropertiesSet():从名字上就能看出,这个其实不是bean真正的初始化方法,而是在bean构建完成,设置好了属性之后调用的方法-----作用相当于初始化方法

    destroy():当bean销毁时,会把单实例bean进行销毁

    Bike.java

    package cap5.bean;
    
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    
    public class Bike implements InitializingBean,DisposableBean{
    
    	public Bike() {
    		// TODO Auto-generated constructor stub
    		super();
    		System.out.println("bike construct...");
    	}
    	public void destroy() throws Exception {
    		// TODO Auto-generated method stub
    		System.out.println("bike destroy");
    	}
    
    	public void afterPropertiesSet() throws Exception {
    		// TODO Auto-generated method stub
    		System.out.println("bike init...");
    		
    	}
    
    }

     MainConfig.java

    package cap5.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.context.annotation.ComponentScan.Filter;
    
    import cap5.bean.Bike;
    import cap5.bean.Jeep;
    import cap5.bean.TaolongBeanPostProcessor;
    import cap5.bean.Train;
    //@ComponentScan(value= {"cap5.bean"},includeFilters= {@Filter(type=FilterType.ASSIGNABLE_TYPE,classes=TaolongBeanPostProcessor.class)})
    @Configuration
    public class MainConfig {
    
    	/*@Bean(initMethod="init",destroyMethod="destroy")
    	public Train train() {
    		return new Train();
    	}*/
    	
    	@Bean
    	public Bike bike() {
    		return new Bike();
    	}
    	
    	/*@Bean
    	public Jeep jeep() {
    		return new Jeep();
    	}*/
    }

    MainTest.java和上面的一样,就不再贴上来了

    测试结果:

    3,使用JSR250规则定义的注解来实现,JSR250的详细了解可自行百度,主要使用如下两个注解

    @PostConstruct:从名字上也能看出这个注解的意思,就是在bean构建完成之后调用---相当于初始化

    @PreDestroy:从名字上也能看出是在beandestroy之前会执行的被注解的方法---相当于销毁

    Jeep.java

    package cap5.bean;
    import javax.annotation.*;
    
    public class Jeep {
    
    	public Jeep() {
    		// TODO Auto-generated constructor stub
    		super();
    		System.out.println("jeep construct...");
    	}
    	
    	@PostConstruct
    	public void init() {
    		System.out.println("jeep init...");
    	}
    	
    	@PreDestroy
    	public void destroy() {
    		System.out.println("jeep destroy...");
    	}
    }

     MainConfig.java

    package cap5.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.context.annotation.ComponentScan.Filter;
    
    import cap5.bean.Bike;
    import cap5.bean.Jeep;
    import cap5.bean.TaolongBeanPostProcessor;
    import cap5.bean.Train;
    //@ComponentScan(value= {"cap5.bean"},includeFilters= {@Filter(type=FilterType.ASSIGNABLE_TYPE,classes=TaolongBeanPostProcessor.class)})
    @Configuration
    public class MainConfig {
    
    	/*@Bean(initMethod="init",destroyMethod="destroy")
    	public Train train() {
    		return new Train();
    	}*/
    	
    	/*@Bean
    	public Bike bike() {
    		return new Bike();
    	}*/
    	
    	@Bean
    	public Jeep jeep() {
    		return new Jeep();
    	}
    }

     MainTest.java和上面一样,不重新贴了

    运行结果:

    4,第四种方法是使用后置处理器,在bean初始化前后时会调用实现了BeanPostProcessor接口并重写两个方法,分别是:postProcessBeforeInitialization()postProcessAfterInitialization()方法

    TaolongBeanPostProcessor.java

    package cap5.bean;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.stereotype.Component;
    @Component
    public class TaolongBeanPostProcessor implements BeanPostProcessor {
    
    
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("bean-----"+beanName+" init start...");
    		return bean;
    	}
    	
    
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    		// TODO Auto-generated method stub
    		
    		System.out.println("bean------"+beanName+" init end...");
    		return bean;
    	}
    }

     Plane.java

    package cap5.bean;
    
    public class Plane {
    
    	public Plane() {
    		// TODO Auto-generated constructor stub
    		System.out.println("plane construct...");
    	}
    	
    }

     MainConfig.java

    package cap5.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.context.annotation.ComponentScan.Filter;
    
    import cap5.bean.Bike;
    import cap5.bean.Jeep;
    import cap5.bean.Plane;
    import cap5.bean.TaolongBeanPostProcessor;
    import cap5.bean.Train;
    //@ComponentScan(value= {"cap5.bean"},includeFilters= {@Filter(type=FilterType.ASSIGNABLE_TYPE,classes=TaolongBeanPostProcessor.class)})
    @Configuration
    public class MainConfig {
    
    	/*@Bean(initMethod="init",destroyMethod="destroy")
    	public Train train() {
    		return new Train();
    	}*/
    	
    	/*@Bean
    	public Bike bike() {
    		return new Bike();
    	}*/
    	
    	/*@Bean
    	public Jeep jeep() {
    		return new Jeep();
    	}*/
    	@Bean
    	public Plane plane() {
    		return new Plane();
    	}
    	
    	@Bean
    	public TaolongBeanPostProcessor taolongBeanPostProcessor() {
    		return new TaolongBeanPostProcessor();
    	}
    }

    测试效果:

    上面都是默认情况下的单例的bean模式,加入在多个bean的情况下呢?容器如何管理bean的生命周期呢?

    (1)当bean是多实例的模式下,bean不会在IOC容器创建的时候,去实例化bean,而是在真正使用该bean的时候实例化,这一点可以进行简单的测试一下,当增加@scope(”protorype“)时,就是多实例创建bean了

    (2)当容器关闭的时候,多实例的情况下怎么处理,会不会将多个实例同时销毁呢?

    我们来简单的测试一下:

    MainConfig.java部分代码

    @Scope("prototype")
    	@Bean
    	public Bike bike() {
    		return new Bike();
    	}

    MianTest.java

    package cap5.test;
    
    import org.junit.Test;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import cap5.bean.Bike;
    import cap5.config.MainConfig;
    
    public class MainTest {
    
    	@Test
    	public void test() {
    		AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
    		System.out.println("IOC 容器创建完成");
    		Bike bike1 = (Bike)app.getBean(Bike.class);
    		Bike bike2 = (Bike)app.getBean(Bike.class);
    		System.out.println(bike1==bike2);
    		System.out.println("IOC 容易准备关闭");
    		/*String[] names = app.getBeanDefinitionNames();
    		for(String name:names) {
    			System.out.println("name="+name);
    		}*/
    		app.close();
    		
    	}
    }

     运行结果:

    这个结果证实了一下问题

    1,多实例的时候bean不会随着IOC容器的构建而创建,而是在使用的时候创建的getBean()

    2,多实例的时候,当容器进行关闭的时候,bean实例不会调用destroy方法,说明容器不控制多实例的销毁

    3,多实例的情况下,返回的bean的对象时不一样的,返回为false

    展开全文
  • Springbean生命周期

    2019-08-07 07:48:07
    介绍了SpringBean周期,容器周期,工厂周期,运行代码后可以看到运行结果
  • Spring中bean的作用域与生命周期

    万次阅读 多人点赞 2017-06-17 22:29:18
    Spring中,那些组成应用程序的主体及由Spring IoC容器所管理的对象,被称之为bean。简单地讲,bean就是由IoC容器初始化、装配及管理的对象,除此之外,bean就与应用程序的其他对象没有什么区别了。而bean的定义...

      在Spring中,那些组成应用程序的主体及由Spring IoC容器所管理的对象,被称之为bean。简单地讲,bean就是由IoC容器初始化、装配及管理的对象,除此之外,bean就与应用程序中的其他对象没有什么区别了。而bean的定义以及bean相互间的依赖关系将通过配置元数据来描述。

      Spring中的bean默认都是单例的,对于Web应用来说,Web容器对于每个用户请求都创建一个单独的Sevlet线程来处理请求,引入Spring框架之后,每个Action都是单例的,那么对于Spring托管的单例Service Bean,Spring的单例是基于BeanFactory也就是Spring容器的,单例Bean在此容器内只有一个,Java的单例是基于JVM,每个JVM内只有一个实例。

    1、bean的作用域

      创建一个bean定义,其实质是用该bean定义对应的类来创建真正实例的“配方”。把bean定义看成一个配方很有意义,它与class很类似,只根据一张“处方”就可以创建多个实例。不仅可以控制注入到对象中的各种依赖和配置值,还可以控制该对象的作用域。这样可以灵活选择所建对象的作用域,而不必在Java Class级定义作用域。Spring Framework支持五种作用域,分别阐述如下表。

      五种作用域中,request、session和global session三种作用域仅在基于web的应用中使用(不必关心你所采用的是什么web应用框架),只能用在基于web的Spring ApplicationContext环境。

      (1)当一个bean的作用域为Singleton,那么Spring IoC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例。Singleton是单例类型,就是在创建起容器时就同时自动创建了一个bean的对象,不管你是否使用,他都存在了,每次获取到的对象都是同一个对象。注意,Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton,可以这样配置:

    <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">
    

      (2)当一个bean的作用域为Prototype,表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean()方法)时都会创建一个新的bean实例。Prototype是原型类型,它在我们创建容器的时候并没有实例化,而是当我们获取bean的时候才会去创建一个对象,而且我们每次获取到的对象都不是同一个对象。根据经验,对有状态的bean应该使用prototype作用域,而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype,可以这样配置:

    <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
     <!--或者-->
    <bean id="account" class="com.foo.DefaultAccount" singleton="false"/> 
    

      (3)当一个bean的作用域为Request,表示在一次HTTP请求中,一个bean定义对应一个实例;即每个HTTP请求都会有各自的bean实例,它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

    <bean id="loginAction" class=com.foo.LoginAction" scope="request"/>
    

      针对每次HTTP请求,Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例,且该loginAction bean实例仅在当前HTTP request内有效,因此可以根据需要放心的更改所建实例的内部状态,而其他请求中根据loginAction bean定义创建的实例,将不会看到这些特定于某个请求的状态变化。当处理请求结束,request作用域的bean实例将被销毁。

      (4)当一个bean的作用域为Session,表示在一个HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

    <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>
    

      针对某个HTTP Session,Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例,且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样,可以根据需要放心的更改所创建实例的内部状态,而别的HTTP Session中根据userPreferences创建的实例,将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候,在该HTTP Session作用域内的bean也会被废弃掉。

      (5)当一个bean的作用域为Global Session,表示在一个全局的HTTP Session中,一个bean定义对应一个实例。典型情况下,仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

    <bean id="user" class="com.foo.Preferences "scope="globalSession"/>
    

      global session作用域类似于标准的HTTP Session作用域,不过仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念,它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。

    2、bean的生命周期

      Spring中Bean的实例化过程:

      Bean的生命周期:

      Bean实例生命周期的执行过程如下:

    • Spring对bean进行实例化,默认bean是单例;

    • Spring对bean进行依赖注入;

    • 如果bean实现了BeanNameAware接口,Spring将bean的名称传给setBeanName()方法;

    • 如果bean实现了BeanFactoryAware接口,Spring将调用setBeanFactory()方法,将BeanFactory实例传进来;

    • 如果bean实现了ApplicationContextAware接口,它的setApplicationContext()方法将被调用,将应用上下文的引用传入到bean中;

    • 如果bean实现了BeanPostProcessor接口,它的postProcessBeforeInitialization()方法将被调用;

    • 如果bean中有方法添加了@PostConstruct注解,那么该方法将被调用;

    • 如果bean实现了InitializingBean接口,spring将调用它的afterPropertiesSet()接口方法,类似的如果bean使用了init-method属性声明了初始化方法,该方法也会被调用;

    • 如果在xml文件中通过<bean>标签的init-method元素指定了初始化方法,那么该方法将被调用;

    • 如果bean实现了BeanPostProcessor接口,它的postProcessAfterInitialization()接口方法将被调用;

    • 此时bean已经准备就绪,可以被应用程序使用了,他们将一直驻留在应用上下文中,直到该应用上下文被销毁;

    • 如果bean中有方法添加了@PreDestroy注解,那么该方法将被调用;

    • 若bean实现了DisposableBean接口,spring将调用它的distroy()接口方法。同样的,如果bean使用了destroy-method属性声明了销毁方法,则该方法被调用;

      这里特别说明一下Aware接口,Spring的依赖注入最大亮点就是所有的Bean对Spring容器的存在是没有意识的。但是在实际项目中,我们有时不可避免的要用到Spring容器本身提供的资源,这时候要让 Bean主动意识到Spring容器的存在,才能调用Spring所提供的资源,这就是Spring的Aware接口,Aware接口是个标记接口,标记这一类接口是用来“感知”属性的,Aware的众多子接口则是表征了具体要“感知”什么属性。例如BeanNameAware接口用于“感知”自己的名称,ApplicationContextAware接口用于“感知”自己所处的上下文。其实Spring的Aware接口是Spring设计为框架内部使用的,在大多数情况下,我们不需要使用任何Aware接口,除非我们真的需要它们,实现了这些接口会使应用层代码耦合到Spring框架代码中

      其实很多时候我们并不会真的去实现上面所描述的那些接口,那么下面我们就除去那些接口,针对bean的单例和非单例来描述下bean的生命周期:

    2.1 单例管理的对象

      当scope="singleton",即默认情况下,会在启动容器时(即实例化容器时)时实例化。但我们可以指定Bean节点的lazy-init="true"来延迟初始化bean,这时候,只有在第一次获取bean时才会初始化bean,即第一次请求该bean时才初始化。如下配置:

    <bean id="serviceImpl" class="cn.csdn.service.ServiceImpl" lazy-init="true"/>
    

      如果想对所有的默认单例bean都应用延迟初始化,可以在根节点beans设置default-lazy-init属性为true,如下所示:

    <beans default-lazy-init="true">
    

      默认情况下,Spring在读取xml文件的时候,就会创建对象。在创建对象的时候先调用构造器,然后调用init-method属性值中所指定的方法。对象在被销毁的时候,会调用destroy-method属性值中所指定的方法(例如调用Container.destroy()方法的时候)。写一个测试类,代码如下:

    public class LifeBean {
    	private String name;  
        
        public LifeBean(){  
            System.out.println("LifeBean()构造函数");  
        }  
        public String getName() {  
            return name;  
        }  
      
        public void setName(String name) {  
            System.out.println("setName()");  
            this.name = name;  
        }  
    
        public void init(){  
            System.out.println("this is init of lifeBean");  
        }  
          
        public void destory(){  
            System.out.println("this is destory of lifeBean " + this);  
        }  
    }
    

      life.xml配置如下:

    <bean id="life_singleton" class="com.bean.LifeBean" scope="singleton" 
    			init-method="init" destroy-method="destory" lazy-init="true"/>
    

      测试代码如下:

    public class LifeTest {
    	@Test 
    	public void test() {
    		AbstractApplicationContext container = 
    		new ClassPathXmlApplicationContext("life.xml");
    		LifeBean life1 = (LifeBean)container.getBean("life");
    		System.out.println(life1);
    		container.close();
    	}
    }
    

      运行结果如下:

    LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@573f2bb1
    ……
    this is destory of lifeBean com.bean.LifeBean@573f2bb1
    

    2.2 非单例管理的对象

      当scope="prototype"时,容器也会延迟初始化bean,Spring读取xml文件的时候,并不会立刻创建对象,而是在第一次请求该bean时才初始化(如调用getBean方法时)。在第一次请求每一个prototype的bean时,Spring容器都会调用其构造器创建这个对象,然后调用init-method属性值中所指定的方法。对象销毁的时候,Spring容器不会帮我们调用任何方法,因为是非单例,这个类型的对象有很多个,Spring容器一旦把这个对象交给你之后,就不再管理这个对象了。

      为了测试prototype bean的生命周期life.xml配置如下:

    <bean id="life_prototype" class="com.bean.LifeBean" scope="prototype" init-method="init" destroy-method="destory"/>
    

      测试程序如下:

    public class LifeTest {
    	@Test 
    	public void test() {
    		AbstractApplicationContext container = new ClassPathXmlApplicationContext("life.xml");
    		LifeBean life1 = (LifeBean)container.getBean("life_singleton");
    		System.out.println(life1);
    		
    		LifeBean life3 = (LifeBean)container.getBean("life_prototype");
    		System.out.println(life3);
    		container.close();
    	}
    }
    

      运行结果如下:

     
    LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@573f2bb1
    LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@5ae9a829
    ……
    this is destory of lifeBean com.bean.LifeBean@573f2bb1
    

      可以发现,对于作用域为prototype的bean,其destroy方法并没有被调用。如果bean的scope设为prototype时,当容器关闭时,destroy方法不会被调用。对于prototype作用域的bean,有一点非常重要,那就是Spring不能对一个prototype bean的整个生命周期负责:容器在初始化、配置、装饰或者是装配完一个prototype实例后,将它交给客户端,随后就对该prototype实例不闻不问了。不管何种作用域,容器都会调用所有对象的初始化生命周期回调方法。但对prototype而言,任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源,都是客户端代码的职责(让Spring容器释放被prototype作用域bean占用资源的一种可行方式是,通过使用bean的后置处理器,该处理器持有要被清除的bean的引用)。谈及prototype作用域的bean时,在某些方面你可以将Spring容器的角色看作是Java new操作的替代者,任何迟于该时间点的生命周期事宜都得交由客户端来处理。

      Spring容器可以管理singleton作用域下bean的生命周期,在此作用域下,Spring能够精确地知道bean何时被创建,何时初始化完成,以及何时被销毁。而对于prototype作用域的bean,Spring只负责创建,当容器创建了bean的实例后,bean的实例就交给了客户端的代码管理,Spring容器将不再跟踪其生命周期,并且不会管理那些被配置成prototype作用域的bean的生命周期。

    2.3 引申

      在学习Spring IoC过程中发现,每次产生ApplicationContext工厂的方式是:

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    

      这样产生ApplicationContext就有一个弊端,每次访问加载bean的时候都会产生这个工厂,所以这里需要解决这个问题。

      ApplicationContext是一个接口,它继承自BeanFactory接口,除了包含BeanFactory的所有功能之外,在国际化支持、资源访问(如URL和文件)、事件传播等方面进行了良好的支持。

      解决问题的方法很简单,在web容器启动的时候将ApplicationContext转移到ServletContext中,因为在web应用中所有的Servlet都共享一个ServletContext对象。那么我们就可以利用ServletContextListener去监听ServletContext事件,当web应用启动的是时候,我们就将ApplicationContext装载到ServletContext中。 Spring容器底层已经为我们想到了这一点,在spring-web-xxx-release.jar包中有一个已经实现了ServletContextListener接口的类ContextLoader,其源码如下:

    public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
    	private ContextLoader contextLoader;
    
    	public ContextLoaderListener() {
    
    	}
    
    	public ContextLoaderListener(WebApplicationContext context) {
    		super(context);
    	}
    
    	public void contextInitialized(ServletContextEvent event) {
    		this.contextLoader = createContextLoader();
    		if (this.contextLoader == null) {
    			this.contextLoader = this;
    		}
    		this.contextLoader.initWebApplicationContext(event.getServletContext());
    	}
    
    	@Deprecated
    	protected ContextLoader createContextLoader() {
    		return null;
    	}
    
    	@Deprecated
    	public ContextLoader getContextLoader() {
    		return this.contextLoader;
    	}
    
    	public void contextDestroyed(ServletContextEvent event) {
    		if (this.contextLoader != null) {
    		this.contextLoader.closeWebApplicationContext(event.getServletContext());
    		}
    		ContextCleanupListener.cleanupAttributes(event.getServletContext());
    	}
    }
    

      这里就监听到了servletContext的创建过程, 那么 这个类又是如何将applicationContext装入到serveletContext容器中的呢?

      this.contextLoader.initWebApplicationContext(event.getServletContext())方法的具体实现中:

    public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
         if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
             throw new IllegalStateException(
                     "Cannot initialize context because there is already a root application context present - " +
                     "check whether you have multiple ContextLoader* definitions in your web.xml!");
         }
    
         Log logger = LogFactory.getLog(ContextLoader.class);
         servletContext.log("Initializing Spring root WebApplicationContext");
         if (logger.isInfoEnabled()) {
             logger.info("Root WebApplicationContext: initialization started");
         }
         long startTime = System.currentTimeMillis();
    
         try {
         	  // Store context in local instance variable, to guarantee that
              // it is available on ServletContext shutdown.
             if (this.context == null) {
                 this.context = createWebApplicationContext(servletContext);
             }
             if (this.context instanceof ConfigurableWebApplicationContext) {
                 ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
                 if (!cwac.isActive()) {
                     // The context has not yet been refreshed -> provide services such as
                     // setting the parent context, setting the application context id, etc
                     if (cwac.getParent() == null) {
                         // The context instance was injected without an explicit parent ->
                         // determine parent for root web application context, if any.
                         ApplicationContext parent = loadParentContext(servletContext);
                         cwac.setParent(parent);
                     }
                     configureAndRefreshWebApplicationContext(cwac, servletContext);
                 }
             }
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
    
             ClassLoader ccl = Thread.currentThread().getContextClassLoader();
             if (ccl == ContextLoader.class.getClassLoader()) {
                 currentContext = this.context;
             }
             else if (ccl != null) {
                 currentContextPerThread.put(ccl, this.context);
             }
    
             if (logger.isDebugEnabled()) {
                 logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
                         WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
             }
             if (logger.isInfoEnabled()) {
                 long elapsedTime = System.currentTimeMillis() - startTime;
                 logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
             }
    
             return this.context;
         }
         catch (RuntimeException ex) {
             logger.error("Context initialization failed", ex);
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
             throw ex;
         }
         catch (Error err) {
             logger.error("Context initialization failed", err);
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
             throw err;
         }
     }
    

      这里的重点是servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context),用key:WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE value: this.context的形式将applicationContext装载到servletContext中了。另外从上面的一些注释我们可以看出: WEB-INF/applicationContext.xml, 如果我们项目中的配置文件不是这么一个路径的话 那么我们使用ContextLoaderListener 就会出问题, 所以我们还需要在web.xml中配置我们的applicationContext.xml配置文件的路径。

    <listener>
    	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <context-param>
    	<param-name>contextConfigLocation</param-name>
    	<param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    

      剩下的就是在项目中开始使用 servletContext中装载的applicationContext对象了: 那么这里又有一个问题,装载时的key是 WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,我们在代码中真的要使用这个吗? 其实Spring为我们提供了一个工具类WebApplicationContextUtils,接着我们先看下如何使用,然后再去看下这个工具类的源码:

    WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());
    

      接着来看下这个工具类的源码:

    public static WebApplicationContext getWebApplicationContext(ServletContext sc) {
    	return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
    }
    

      这里就能很直观清晰地看到 通过key值直接获取到装载到servletContext中的 applicationContext对象了。

      ContextLoaderListener监听器的作用就是启动Web容器时,自动装配ApplicationContext的配置信息,因为它实现了ServletContextListener这个接口,在web.xml配置这个监听器,启动容器时,就会默认执行它实现的方法。在ContextLoaderListener中关联了ContextLoader这个类,整个加载配置过程由ContextLoader来完成。

    展开全文
  • spring管理bean生命周期

    2016-06-03 13:58:29
    Spring IOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务。 Spring IOC容器对Bean的生命周期进行管理的过程: 1.通过构造器或工厂方法创建Bean实例 2.为Bean的属性设置值和对...
  • Spring中bean生命周期(最详细)

    万次阅读 多人点赞 2020-02-24 14:09:35
    Spring Bean生命周期Spring面试热点问题。Spring Bean生命周期指的是从一个普通的Java类变成Bean的过程,深知Spring源码的人都知道这个给面试官将的话大可将30分钟以上,如果你不知道源码,那么Aware接口和...
  • 今天小编就为大家分享一篇关于spring中bean生命周期详解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • SpringSpring Bean 生命周期.pdf
  • 主要介绍了Spring中Bean生命周期使用解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Spring bean生命周期demo

    2016-07-14 21:37:26
    Spring bean生命周期demo
  • Spring 中Bean生命周期

    千次阅读 多人点赞 2019-05-11 10:09:12
    文章目录Spring 中Bean生命周期前言一、Bean 的完整生命周期二、Bean生命周期验证 前言 ​ 这其实是一道面试题,是我在面试百度的时候被问到的,当时没有答出来(因为自己真的很菜),后来在网上寻找答案,看到...
  • Spring Bean生命周期

    2018-04-23 18:51:34
    spring 的两大核心,IOC与AOP,IOC主要用来管理bean的依赖,耦合代码,但是spring的bean的生命周期也是需要深入理解的,bean...Spring Bean生命周期 关于bean的生命周期大致分为三个类型: - bean自身的方法 ...
  • Spring 中Bean生命周期.pdf
  • 图解Spring中bean生命周期

    千次阅读 2019-08-04 14:07:53
    正确理解Spring bean生命周期非常重要,因为你或许要利用Spring提供的扩展点来完成特定需求。如下图展示了bean 装载到Spring应用上下文中的一个典型的生命周期过程。 接下来我们对该图的内容进行详细解释 ...
  • SpringBean生命周期详解

    千次阅读 2020-10-28 17:51:28
    SpringBean生命周期详解 一、简述: Spring是我们每天都在使用的框架,Bean是被Spring管理的Java对象,是Spring框架最重要的部分之一,那么让我们一起了解一下SpringBean的生命周期是怎样的吧 二、流程图 我们先从...
  • 本篇文章主要介绍了深入理解Spring中bean生命周期介绍,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Spring Bean生命周期.pdf

    2021-04-01 08:38:43
    Springbean生命周期
  • Spring中bean生命周期

    万次阅读 2018-07-18 17:43:20
    Spring 中bean生命周期短暂吗? 在spring中,从BeanFactory或ApplicationContext取得的实例为Singleton,也就是预设为每一个Bean的别名只能维持一个实例,而不是每次都产生一个新的对象使用Singleton模式产生单一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,654
精华内容 31,461
关键字:

spring中bean的生命周期

spring 订阅