springbean生命周期

springbean的生命周期简单来说就是创建bean、使用bean、销毁bean。

但是spring为了框架的拓展性，添加了更多的步骤。

实例化Bean

首先spring使用AbstractAutowireCapableBeanFactory的createBeanInstance来实例化一个初始的bean，这个bean的属性都是默认值

byte, short, int, long: 0
float, double: 0.0
char: '\u0000' (空字符)
boolean: false，

引用数据类型是null。

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        // 解析出bean的class对象
        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());
        }
        //如果实现这个接口可以直接获得bean，而不是通过反射创建
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }

        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);
            }
        }
        //获取class的构造器对象
		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);

初始化

属性注入

调用set方法注入实例化时为默认值的属性（有例外）。

检查aware接口

public interface Aware {

}

可以看到Aware是一个空实现的接口，类似的还有Java的Serializable接口，他们的作用都是标识实现类。

观察Aware的实现类不难发现很多都是BeanFactory这样的与IOC容器相关的类。spring中bean分为两类，一类是自定义的bean，一类的容器自带的bean。普通的属性赋值只能赋值自定义bean，如果你想赋值容器的bean需要实现对应的Aware接口，这样子属性赋值是spring会特殊处理。

public interface BeanFactoryAware extends Aware {

	/**
	 * Callback that supplies the owning factory to a bean instance.
	 * <p>Invoked after the population of normal bean properties
	 * but before an initialization callback such as
	 * {@link InitializingBean#afterPropertiesSet()} or a custom init-method.
	 * @param beanFactory owning BeanFactory (never {@code null}).
	 * The bean can immediately call methods on the factory.
	 * @throws BeansException in case of initialization errors
	 * @see BeanInitializationException
	 */
	void setBeanFactory(BeanFactory beanFactory) throws BeansException;

}

 在invokeAwareMethods中会对实现了这种接口的类特殊处理进行注入。

BeanPostProcessor

此时bean可以说已经可以使用了，但是为了扩展性，spring提供了BeanPostProcessor来进行自定义。BeanPostProcessor提供了两个方法postProcessBeforeInitialization，postProcessAfterInitialization。这其中提到的Initialization不是指广义的初始化bean，而是特定的一个接口InitializingBean。这两个方法的意思就是在InitializingBean接口前，属性注入后或者InitializingBean接口后进行一些操作。最经典的是aop，aop的实现就使用了postProcessAfterInitialization。

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                return this.wrapIfNecessary(bean, beanName, cacheKey);
            }
        }

        return bean;
    }

 

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
            Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
            if (specificInterceptors != DO_NOT_PROXY) {
                this.advisedBeans.put(cacheKey, Boolean.TRUE);
                Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            } else {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return bean;
            }
        } else {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    }

 在这里创建了代理对象，还是使用cglib或者JDK。

InitializingBean

而在上面两个方法执行中间还有一步检测InitializingBean接口，如果实现了这个接口要实现afterPropertiesSet方法，可以在这里执行自定义的初始化逻辑。

比如成员变量中有一个map集合，在这个方法中可以给map赋予初始值。

@Service
public class Example implements InitializingBean {
    @Autowired
    private Map<Integer,Integer> map;

    @Override
    public void afterPropertiesSet() throws Exception {
        map.put(1,1);
        map.put(2,3);
    }
}

到现在bean就正式创建完成了，其中循环依赖的问题下次再说，不过最好还是避免循环依赖。

接下来就是使用bean了，spring会帮你注入bean，正常使用就行。

销毁bean需要使用 调用close方法，一般不使用，不过也有相关的拓展接口DisposableBean可以定义销毁bean之前执行的逻辑。