耐得千事烦
耐得千事烦

SpringIOC中bean的生命周期

  • 定义
    bean的生命周期指的是在Spring中IOC容器从初始化到销毁这一整个全过程。同时在这一过程里关系到各个级别的接口的作用和自定义实现。

先简单说一下bean的整个生命周期：创建（实例化、属性赋值、初始化）、使用、销毁。而spring提供了一些接口允许在这个过程中进行一定程度的扩展。

  • 各个级别的接口
  1. 工厂后处理器接口方法：诸如BeanFactoryPostProcessor，CustomAutowireConfigure等，它们是在容器装置配置文件之后调用，可以说是最先调用的方法了。
  2. 容器级生命周期接口方法：InstantiationAwareBeanPostProcessor（继承自BeanPostProcessor） 和BeanPostProcessor 这两个的接口的实现。我们一般称之为后置处理器
  3. Bean级别生命周期接口：BeanNameAware，BeanFactoryAware，IntializaingBean，DiposableBean 这些接口的方法。每个Bean都可以选择实现，可以选择各自的自定义操作
  4. Bean自身的方法：init-method / destory-method ， 通过在配置文件bean定义的相应属性中，指定相应的执行方法。

现在我们具体的来说一下整个生命周期以及相关的接口的方法执行的时机：
直接上一段代码：

package com.suxin;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

//DDDbean继承自BeanFactoryPostProcessor 是一个工厂后置处理器
public class DDDbean implements BeanFactoryPostProcessor {


    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("DDDbean...BeanFactoryPostProcessor.postProcessBeanFactory 执行中...");
    }


    public DDDbean() {
        System.out.println("DDDbean.构造方法 执行中...");
    }
}


package com.suxin;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;

import java.beans.PropertyDescriptor;
//EEEbean实现了InstantiationAwareBeanPostProcessor 接口（该接口是一个容器级别的生命周期的接口方法）
public class EEEbean implements InstantiationAwareBeanPostProcessor {

    private String name;

    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        System.out.println("EEEbean...InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 执行中...");
        return null;
    }

    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("EEEbean...InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation 执行中...");

        return true;
    }

    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        System.out.println("EEEbean...InstantiationAwareBeanPostProcessor.postProcessPropertyValues 执行中...");
        return pvs;
    }

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("EEEbean...InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization 执行中...");
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("EEEbean...InstantiationAwareBeanPostProcessor.postProcessAfterInitialization 执行中...");
        return bean;
    }

    public EEEbean() {
        System.out.println("EEEbean.构造方法 执行中...");
    }

    public String getName() {
        System.out.println("EEEbean.getName 执行中...");
        return name;
    }

    public void setName(String name) {
        System.out.println("EEEbean.setName 执行中...");
        this.name = name;
    }
}


package com.suxin;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

//FFFbean实现了BeanNameAware、BeanFactoryAware、IntializaingBean、DiposableBean 这四种bean级别的生命周期接口方法
//同时也写了initMethod和destroyMethod俩种方法即将装配到xml的bean配置里的init-method和destroy-method属性
public class FFFbean implements BeanNameAware, BeanFactoryAware, InitializingBean,DisposableBean {

    private String value;

    public void setBeanName(String name) {
        System.out.println("FFFbean.setBeanName 执行中..."+name);
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("FFFbean.setBeanFactory 执行中...");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("FFFbean.afterPropertiesSet 执行中...");
    }

    public void destroy() throws Exception {
        System.out.println("FFFbean.destroy 执行中...");
    }


    public FFFbean() {
        System.out.println("FFFbean.构造方法 执行中...");
    }

    public void doSomething() {
        System.out.println("doSomething...");
    }


    public String getValue() {
        System.out.println("FFFbean.getValue 执行中... " + value);
        return value;
    }

    public void setValue(String value) {
        System.out.println("FFFbean.setValue 执行中... " + value);
        this.value = value;
    }

    public void initMethod() {
        System.out.println("FFFbean.initMethod...");
    }

    public void destroyMethod() {
        System.out.println("FFFbean.destroyMethod...");
    }
}

xml配置相关：

运行main方法

public class App {
    public static void main( String[] args ) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        FFFbean fFFbean= (FFFbean)context.getBean("fFFbean");
        fFFbean.doSomething();
//        context.getAutowireCapableBeanFactory().destroyBean(fFFbean);

        context.close();

执行结果

八月 10, 2019 1:43:17 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@2e0fa5d3: startup date [Sat Aug 10 13:43:17 CST 2019]; root of context hierarchy
八月 10, 2019 1:43:17 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
DDDbean.构造方法 执行中...
DDDbean...BeanFactoryPostProcessor.postProcessBeanFactory 执行中...
EEEbean.构造方法 执行中...
EEEbean.setName 执行中...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 执行中...
FFFbean.构造方法 执行中...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation 执行中...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessPropertyValues 执行中...
FFFbean.setValue 执行中... jiujiu
FFFbean.setBeanName 执行中...fFFbean
FFFbean.setBeanFactory 执行中...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization 执行中...
FFFbean.afterPropertiesSet 执行中...
FFFbean.initMethod...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessAfterInitialization 执行中...
doSomething...
八月 10, 2019 1:43:19 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@2e0fa5d3: startup date [Sat Aug 10 13:43:17 CST 2019]; root of context hierarchy
FFFbean.destroy 执行中...
FFFbean.destroyMethod...

Process finished with exit code 0

ok，代码相关已经贴完，我们开始来解释一下。当然以上代码如果感兴趣可以直接复制下来，自己运行一遍，加深印象。

贴一段AbstractApplicationContext的refresh方法的源码，我会忽略一些不是本章关注的代码

    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            // ...

            // Tell the subclass to refresh the internal bean factory.
            // ...

            // Prepare the bean factory for use in this context.
            // ...

            try {
                // 让继承容器的子类容器进行扩展的
                postProcessBeanFactory(beanFactory);

                // 创建BeanFactoryPostProcessor实例，并且调用相关方法，也就是在这个方法里DDDbean会被初始化，且会被调用相关方法
                invokeBeanFactoryPostProcessors(beanFactory);

                // 初始化实现了BeanPostProcessor 和 InstantiationAwareBeanPostProcessor接口方法的bean，也就是说这里EEEbean被初始化 ps:还未调用相关方法
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                // ...

                // Initialize event multicaster for this context.
                // ...

                // Initialize other special beans in specific context subclasses.
                // ...

                // Check for listener beans and register them.
                // ...

                // 完成初始化的工作，等会会深入进入看看
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                // ...
            }

            catch (BeansException ex) {
                // ...

                // Destroy already created singletons to avoid dangling resources.
                // ...

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // 重置Spring核心中常见的默认缓存，因为我们
                // 可能不再需要用于单例bean的元数据了…
                resetCommonCaches();
            }
        }
    }

首先是DDDbean的构造方法被执行了，然后继续执行这个bean的实现了BeanFactoryPostProcessor的postProcessBeanFactory方法。ok第一步已经出来了BeanFactoryPostProcessor这种级别的bean会被首先初始化然后紧接着就是调用该bean的postProcessBeanFactory方法。
其发生的时机就是在AbstractApplicationContext的refresh方法里的调用invokeBeanFactoryPostProcessors方法
贴一段invokeBeanFactoryPostProcessors的源码（已经删除非重点代码）：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

        // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
        // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }
//继续看代码
//PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
//这是个静态方法，由于代码很多我就忽略了非本章关注的代码
public static void invokeBeanFactoryPostProcessors(
            ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

        // Invoke BeanDefinitionRegistryPostProcessors first, if any.
        Set processedBeans = new HashSet();

        // ......

        // 获取到所有工厂后处理器接口实现类的名字,DDDbean的名字就包含在里面
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // 为容器内的BeanFactoryPostProcessor规定创建顺序和执行方法的顺序
        // 优先级最高的是priorityOrdered，其次是ordered，最后的是nonOrdered
        List priorityOrderedPostProcessors = new ArrayList();
        List orderedPostProcessorNames = new ArrayList();
        List nonOrderedPostProcessorNames = new ArrayList();
        for (String ppName : postProcessorNames) {
            if (processedBeans.contains(ppName)) {
                // skip - already processed in first phase above
            }
            else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            }
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            }
            else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }

        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
        // ...... 

        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
        // ......

        // 关注这个部分，DDDbean即将在这里被初始化然后调用它的方法
        List nonOrderedPostProcessors = new ArrayList();
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

        // 清除缓存的合并bean定义，因为后处理器可能
        // 修改了原始元数据，例如替换值中的占位符…
        beanFactory.clearMetadataCache();
    }

通过源码解读，我们可以了解到为什么DDDbean会优先被初始化且被调用实现的postProcessBeanFactory方法。
接下来我们继续看到EEEbean被初始化（实例化+属性赋值），且相对于FFFbean来说是优先初始化。继续看源码，这一次我们深入到registerBeanPostProcessors(beanFactory)方法里去看。非本章关注代码已经忽略

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

//继续深入进去看 省略无关代码
public static void registerBeanPostProcessors(
            ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
        // 获取到了EEEbean的名字放在了postProcessorNames 数组里面
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

        // Register BeanPostProcessorChecker that logs an info message when
        // a bean is created during BeanPostProcessor instantiation, i.e. when
        // a bean is not eligible for getting processed by all BeanPostProcessors.
        // ......

        // Separate between BeanPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        List priorityOrderedPostProcessors = new ArrayList();
        List internalPostProcessors = new ArrayList();
        List orderedPostProcessorNames = new ArrayList();
        List nonOrderedPostProcessorNames = new ArrayList();
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                priorityOrderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                    internalPostProcessors.add(pp);
                }
            }
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            }
            else {
                //关注一下这个方法 EEEbean的名字被放到这个集合里面
                nonOrderedPostProcessorNames.add(ppName);
            }
        }

        // First, register the BeanPostProcessors that implement PriorityOrdered.
        // ......

        // Next, register the BeanPostProcessors that implement Ordered.
        // ......

        // Now, register all regular BeanPostProcessors.
        List nonOrderedPostProcessors = new ArrayList();
        for (String ppName : nonOrderedPostProcessorNames) {
            // 关注点在这里，初始化BeanPostProcessor相关类 也就是EEEbean在这里进行初始化（实例化+属性赋值）
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            nonOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

        // Finally, re-register all internal BeanPostProcessors.
        // ......

        // Re-register post-processor for detecting inner beans as ApplicationListeners,
        // moving it to the end of the processor chain (for picking up proxies etc).
        // ......
    }

OK通过上面的源码解释了为什么EEEbean先FFFbean一步进行初始化了。
继续看源码refresh方法里finishBeanFactoryInitialization(beanFactory)的方法

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // Initialize conversion service for this context.
        // ... ...

        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
        // ......

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        // ......

        // Stop using the temporary ClassLoader for type matching.
        // ......

        // Allow for caching all bean definition metadata, not expecting further changes.
        // ......

        // 重点关注方法
        beanFactory.preInstantiateSingletons();
    }

继续看beanFactory.preInstantiateSingletons();

public void preInstantiateSingletons() throws BeansException {
        // ......

        // Iterate over a copy to allow for init methods which in turn register new bean definitions.
        // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
        List beanNames = new ArrayList(this.beanDefinitionNames);

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    // ......
                }
                else {
                    //重点方法 关注一波
                    getBean(beanName);
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        // ......
    }

继续看getBean方法，其实就是看doGetBean方法（继续省略不是本章关注重点的代码）：

protected  T doGetBean(
            final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {

        final String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            // ......
        }

        else {
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            // ......

            // Check if bean definition exists in this factory.
            // ......

            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.
                // ......

                // 关注单例的bean的创建 重点关注createBean方法
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                // 重点就这个方法里
                                return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {
                                
                                destroySingleton(beanName);
                                throw ex;
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

                else if (mbd.isPrototype()) {
                    // It's a prototype -> create a new instance.
                    // ......
                }

                else {
                    // ......
                    catch (IllegalStateException ex) {
                        // ......
                    }
                }
            }
            catch (BeansException ex) {
                // ......
            }
        }

        // Check if required type matches the type of the actual bean instance.
        // ......
        return (T) bean;
    }


继续看createBean的方法（同样还是忽略不必要的代码）


@Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        // ......
        RootBeanDefinition mbdToUse = mbd;

        // Make sure bean class is actually resolved at this point, and
        // clone the bean definition in case of a dynamically resolved Class
        // which cannot be stored in the shared merged bean definition.
        // ......

        // Prepare method overrides.
        // ......

        try {
            // 首先关注这个方法
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }
        //docreateBean的方法依然是我们关注的重点。
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        // ......
        return beanInstance;
    }



ok，通过上面的代码我们已经提炼处我们需要关注的俩个方法：resolveBeforeInstantiation(beanName, mbdToUse)和doCreateBean(beanName, mbdToUse, args)，ok我们一个个来看：
 首先是resolveBeforeInstantiation的源码：


protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            // Make sure bean class is actually resolved at this point.
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                    //就是这里会调用一次EEEbean的postProcessBeforeInstantiation方法，
                    // 具体的方法大家进去看一下非常简单。
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }



上面的代码说明了EEEbean会被调用实现的postProcessBeforeInstantiation方法，同时因为该方法在EEEbean的实现里返回的是一个null，所以不会立即执行EEEbean的postProcessAfterInstantiation方法，会放在后面来执行。（对了此时我们得明白一下现在的情况，DDDbean和EEEbean已经被初始化了，但是FFFbean还没有完成初始化（按照目前的这个代码进度来说FFFbean的实例化还未完成））
 继续,我们来看doCreateBean方法代码


protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
            throws BeanCreationException {

        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            //关注一下这里，在这里会完成FFFbean的实例化，也就是FFFbean的构造方法会被调用
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
        Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
        mbd.resolvedTargetType = beanType;

        // Allow post-processors to modify the merged bean definition.
        // ......

        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        // ......

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            // 关注这个方法，会完成FFFbean的属性注入
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                // 关注这个方法，完成bean的相关实现方法的回调
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }
        catch (Throwable ex) {
            // ......
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName,
                                "Bean with name '" + beanName + "' has been injected into other beans [" +
                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                "] in its raw version as part of a circular reference, but has eventually been " +
                                "wrapped. This means that said other beans do not use the final version of the " +
                                "bean. This is often the result of over-eager type matching - consider using " +
                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        // Register bean as disposable.
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }



通过上面的源码我们可以看到主要有三个方法值得关注createBeanInstance、populateBean、initializeBean。createBeanInstance完成了FFFbean的实例化（也就是调用了FFFbean的构造方法）
 我们来重点关注一下populateBean方法


protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        PropertyValues pvs = mbd.getPropertyValues();

        // ......

        // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
        // state of the bean before properties are set. This can be used, for example,
        // to support styles of field injection.
        boolean continueWithPropertyPopulation = true;

        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    //关注这里，解释了为什么EEEbean执行了postProcessAfterInstantiation方法
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }

        if (!continueWithPropertyPopulation) {
            return;
        }

        // ......

        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        //关注一下这里，会执行EEEbean的postProcessPropertyValues方法
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
            if (needsDepCheck) {
                checkDependencies(beanName, mbd, filteredPds, pvs);
            }
        }
        //执行FFFbean的赋值操作，FFFbean的setValue方法
        applyPropertyValues(beanName, mbd, bw, pvs);
    }



以上，populateBean方法解释完了，DDDbean和EEEbean都已经被初始化了而FFFbean已经完成了实例化和属性注值，现在就差FFFbean的实现相关接口的方法回调了。我们继续看initializeBean方法。


protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction() {
                @Override
                public Object run() {
                    invokeAwareMethods(beanName, bean);
                    return null;
                }
            }, getAccessControlContext());
        }
        else {
            //重点关注一下这个方法，回调了FFFbean实现了
            //BeanNameAware和BeanFactoryAware接口的方法,具体的
            //大家点击进去看一下，代码很简单
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //关注重点 此方法里回调了EEEbean的postProcessBeforeInitialization方法，大家可以自己点进去，非常简单明了
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            //关注重点 在这个方法里主要执行了FFFbean实现了InitializingBean接口的方法和自身initMethod属性的方法。
            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()) {
            //关注重点  此方法里回调了EEEbean的postProcessAfterInitialization方法，大家可以自己点进去，非常简单明了
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }


至此，FFFbean完成了初始化的所有工作（实例化+属性注入+接口方法回调），而且整个控制台打印的东西里doSomething之前的打印部分已经解释完毕。我们现在再把整个空调台打印的东西展示一下，防止大家忘记：


八月 10, 2019 1:43:17 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@2e0fa5d3: startup date [Sat Aug 10 13:43:17 CST 2019]; root of context hierarchy
八月 10, 2019 1:43:17 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
DDDbean.构造方法 执行中...
DDDbean...BeanFactoryPostProcessor.postProcessBeanFactory 执行中...
EEEbean.构造方法 执行中...
EEEbean.setName 执行中...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 执行中...
FFFbean.构造方法 执行中...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation 执行中...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessPropertyValues 执行中...
FFFbean.setValue 执行中... jiujiu
FFFbean.setBeanName 执行中...fFFbean
FFFbean.setBeanFactory 执行中...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization 执行中...
FFFbean.afterPropertiesSet 执行中...
FFFbean.initMethod...
EEEbean...InstantiationAwareBeanPostProcessor.postProcessAfterInitialization 执行中...
doSomething...
八月 10, 2019 1:43:19 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@2e0fa5d3: startup date [Sat Aug 10 13:43:17 CST 2019]; root of context hierarchy
FFFbean.destroy 执行中...
FFFbean.destroyMethod...

Process finished with exit code 0



接着我们把main方法的代码再次展示一下：


public class App {
    public static void main( String[] args ) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        FFFbean fFFbean= (FFFbean)context.getBean("fFFbean");
        fFFbean.doSomething();
//        context.getAutowireCapableBeanFactory().destroyBean(fFFbean);

        context.close();



ok，fffbean对象执行了doSomething方法。紧接着就是容器的关闭。


在容器关闭的方法里，会先调用FFFbean实现DisposableBean的destroy方法，然后再接着调用FFFbean本身的destoryMethod属性里的方法
 具体的感兴趣的可以自己看源码一步步的debug。


跟着源码走一遍，估计大家这会都有点晕乎了，我们来做一些总结吧：
 首先Spring的bean的生命周期只有五步：实例化、属性赋值、初始化、使用、销毁。


实例化、属性赋值、初始化分别对应三个方法，都是在doCreateBean方法里面，也就是createBeanInstance、populateBean、initializeBean。


说完了bean的生命周期，我们来说一下各个接口的方法调用的时机。
 BeanFactoryPostProcessor类型的接口bean是最先被创建（实例化、属性注入、初始化）并且被调用的postProcessBeanFactory方法的。该时机是refresh方法里的invokeBeanFactoryPostProcessors方法里。refresh的registerBeanPostProcessors方法里主要是做了BeanPostProcessor类型（包括InstantiationAwareBeanPostProcessor）的创建（实例化、属性注入、初始化），而InstantiationAwareBeanPostProcessor类型的方法调用的时机是在doCreateBean里。


InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法会在createBeanInstance（实例化）之前调用，而它的postProcessAfterInstantiation方法则会在createBeanInstance（实例化）之后调用。在populateBean（属性注入）方法里会调用它的postProcessPropertyValues。


接下来就是各种bean级别的生命周期接口诸如beanNameAware、BeanFactoryAware都会在initializeBean（初始化方法里）里面首先调用，然后调用的是BeanPostProcessor接口的postProcessBeforeInitialization方法，后面接着就是InitializingBean接口的afterPropertiesSet方法，最后再次调用BeanPostProcessor接口的postProcessAfterInitialization方法。


说完了创建阶段，再说一下销毁阶段，销毁阶段就是先调用DisposableBean接口的destroy方法，然后再调用bean自身的destroyMethod关联的方法。


至此整个bean的生命周期和接口方法的扩展时机我们就说完了，可能有点多有点杂，大家多看看，最好能根据我的代码自己跑一遍debug一遍，相信就会了解的更加深刻。
























你可能感兴趣的:(SpringIOC中bean的生命周期)






    

  • 斤斤计较的婚姻到底有多难？
白心之岂必有为

    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    

    • 

  • 情绪觉察日记第37天
露露_e800

    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    

    • 

  • 芦花鞋一四
许叶晗

    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    

    • 

  • QQ群采集助手，精准引流必备神器
2401_87347160
其他经验分享

    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    

    • 

  • 关于沟通这件事，项目经理不需要每次都面对面进行
流程大师兄

    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    

    • 

  • 机器学习与深度学习间关系与区别
ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python

    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    

    • 

  • android系统selinux中添加新属性property
辉色投像

    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    

    • 

  • 铭刻于星（四十二）
随风至

    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    

    • 

  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
造命者说

    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    

    • 

  • 2020-01-25
晴岚85

    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    

    • 

  • 随笔 | 仙一般的灵气
海思沧海

    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    

    • 

  • 想家
爆米花机

    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    

    • 

  • 【iOS】MVC设计模式
Magnetic_h
iosmvc设计模式objective-c学习ui

    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    

    • 

  • OC语言多界面传值五大方式
Magnetic_h
iosui学习objective-c开发语言

    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    

    • 

  • 一百九十四章. 自相矛盾
巨木擎天

    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    

    • 

  • UI学习——cell的复用和自定义cell
Magnetic_h
ui学习

    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    

    • 

  • element实现动态路由+面包屑
软件技术NINI
vue案例vue.js前端

    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    

    • 

  • 10月|愿你的青春不负梦想-读书笔记-01
Tracy的小书斋

    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    

    • 

  • C语言宏函数
南林yan
C语言c语言

    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<

    • 

  • 地推话术，如何应对地推过程中家长的拒绝
校师学

    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    

    • 

  • 谢谢你们，爱你们！
鹿游儿

    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    

    • 

  • C语言如何定义宏函数？
小九格物
c语言

    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    

    • 

  • 微服务下功能权限与数据权限的设计与实现
nbsaas-boot
微服务java架构

    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    

    • 

  • 理解Gunicorn：Python WSGI服务器的基石
范范0825
ipythonlinux运维

    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    

    • 

  • 小丽成长记（四十三）
玲玲54321

    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    

    • 

  • 学点心理知识，呵护孩子健康
静候花开_7090

    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    

    • 

  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
黄错错加油

    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    

    • 

  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
尐尐呅

    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    

    • 

  • c++ 的iostream 和 c++的stdio的区别和联系
黄卷青灯77
c++算法开发语言iostreamstdio

    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    

    • 

  • 瑶池防线
谜影梦蝶

    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
    

    • 

  • ztree异步加载
3213213333332132
JavaScriptAjaxjsonWebztree

    相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。
我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。
设置setting，这里只关注async属性的配置
var setting = {
//异步加载配置

    

    • 

  • thirft rpc 具体调用流程
BlueSkator
中间件rpcthrift

    Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作：
        （1）     将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
    

    • 

  • 异或运算推导, 交换数据
dcj3sjt126com
PHP异或^

    /*
* 5 0101
* 9 1010
*
* 5 ^ 5
* 0101
* 0101
* -----
* 0000
* 得出第一个规律: 相同的数进行异或, 结果是0
*
* 9 ^ 5 ^ 6
* 1010
* 0101
* ----
* 1111
*
* 1111
* 0110
* ----
* 1001

    

    • 

  • 事件源对象
周华华
JavaScript

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml&q
    

    • 

  • MySql配置及相关命令
g21121
mysql

            MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。
 
        一 修改MySQL密码及用户
     
    

    • 

  • [简单]poi删除excel 2007超链接
53873039oycg
Excel

          采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下:
    
public void removeExcel2007AllHyperLink(String filePath) throws Exception {
OPCPackage ocPkg = OPCPac
    

    • 

  • Struts2添加 open flash chart
云端月影

    准备以下开源项目：
1. Struts 2.1.6
2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009)
3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。
4. log4j
用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
    

    • 

  • spring包详解
aijuans
spring

    
下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
    

    • 

  • 网站推广之seo概念
antonyup_2006
算法Web应用服务器搜索引擎Google

       持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。
    所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。
    网站推广策略有很多，seo，email，adv
    

    • 

  • 单例模式,sql注入,序列
百合不是茶
单例模式序列sql注入预编译

     
序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时 需要使用序列创建一个自增长的字段  居然不会了,所以将序列写在本篇的前面
 
 1,序列是一个保存数据连续的增长的一种方式;
序列的创建;
CREATE SEQUENCE seq_pro
2 INCREMENT BY 1 -- 每次加几个
3 
    

    • 

  • Mockito单元测试实例
bijian1013
单元测试mockito

    Mockito单元测试实例：
public class SettingServiceTest {
private List<PersonDTO> personList = new ArrayList<PersonDTO>();
@InjectMocks
private SettingPojoService settin
    

    • 

  • 精通Oracle10编程SQL(9)使用游标
bijian1013
oracle数据库plsql

    /*
*使用游标
*/
--显示游标
--在显式游标中使用FETCH...INTO语句
DECLARE
CURSOR emp_cursor is
select ename,sal from emp where deptno=1;
v_ename emp.ename%TYPE;
v_sal emp.sal%TYPE;
begin
ope
    

    • 

  • 【Java语言】动态代理
bit1129
java语言

      JDK接口动态代理
JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联
 
package com.tom;
import com.tom.model.User;
import com.tom.service.IUserService;

    

    • 

  • Java通信之URL通信基础
白糖_
javajdkwebservice网络协议ITeye

    java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。
在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。
学习准备：建议首先学习java的IO基础知识
 
URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
    

    • 

  • 博弈Java讲义 - Java线程同步 (1)
boyitech
java多线程同步锁

     
在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。
   同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
    

    • 

  • java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。
bylijinnan
java

    
public class DeleteExtraSpace {
/**
* 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。
* 方法1.用已有的String类的trim和replaceAll方法
* 方法2.全部用正则表达式，这个我不熟
* 方法3.“重新发明轮子”，从头遍历一次
*/
public static v
    

    • 

  • An error has occurred.See the log file错误解决！
Kai_Ge
MyEclipse

    今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！
很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！
打开日志文件！找到当日错误文件内容：
--------------------------------------------------------------------------
    

    • 

  • [矿业与工业]修建一个空间矿床开采站要多少钱?
comsci

    
       地球上的钛金属矿藏已经接近枯竭...........
       我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床.....
       那么,现在要编制一个预算,提交给财政部门..
    

    • 

  • 解析Google Map Routes
dai_lm
google api

    为了获得从A点到B点的路劲，经常会使用Google提供的API，例如
[url]
http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false
[/url]
从返回的结果上，大致可以了解应该怎么走，但
    

    • 

  • SQL还有多少“理所应当”？
datamachine
sql

    转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！
------------------------------------华丽的分割线--------------------------------

    

    • 

  • Yii使用Ajax验证时，如何设置某些字段不需要验证
dcj3sjt126com
Ajaxyii

    经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如:
$form=$this->beginWidget('CActiveForm', array(        'id'=>'usuario-form',&
    

    • 

  • 使用git同步网站代码
dcj3sjt126com
crontabgit

    转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com
 
管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
    

    • 

  • sql基本操作
蕃薯耀
sqlsql基本操作sql常用操作

    sql基本操作
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
蕃薯耀 2015年6月1日 17:30:33 星期一
 
 
&
    

    • 

  • Spring4+Hibernate4+Atomikos3.3多数据源事务管理
hanqunfeng
Hibernate4

    Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/   一.pom.xml
<dependency>
<
    

    • 

  • jquery中两个值得注意的方法one()和trigger()方法
jackyrong
trigger

      在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍
1） one方法
    one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为
   one(type,${data},fn)
&nb
    

    • 

  • 拿工资不仅仅是让你写代码的
lampcy
工作面试咨询

    这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。
这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。
话粗理不粗。
付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
    

    • 

  • 架构师之对象操作----------对象的效率复制和判断是否全为空
nannan408
架构师

    1.前言。
  如题。
2.代码。
(1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier
Src src=new Src();
BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);

    

    • 

  • ajax 被缓存的解决方案
Rainbow702
JavaScriptjqueryAjaxcache缓存

    使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。
今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。
解决方法如下：
① 直接使用 JQuery提供的 “cache”参数，
    

    • 

  • 修改date.toLocaleString()的警告
tntxia
String

     
我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时 的API，代替的方法如下：
 
package com.tntxia.htmlmaker.util;
import java.text.SimpleDateFormat;
import java.util.
    

    • 

  • 项目完成后的小总结
xiaomiya
js总结项目

    项目完成了，突然想做个总结但是有点无从下手了。
做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。
先说说项目主要实现的功能吧
1，按键精灵
2，获取行情数据
3，各种input输入条件判断
4，发送数据（有json格式和string格式）
5，获取预警条件列表和预警结果列表，
6，排序，
7，预警结果分页获取
8，导出文件（excel，text等）
9，修
    

    •