繁书_
繁书_

Spring Bean 生命周源码解析

Spring Bean生命周期

前言

在使用Spring框架进行开发，一般我们都会将项目中的Bean托管给Spring，也就是俗称的IOC

被Spring管理的单例(singleton)Bean 从创建到销毁，中间的过程都会有完整的生命周期，原型(prototype)Bean只有创建的生命周期没有销毁的生命周期，因为Spring在创建完原型Bean之后就不再有Bean的控制权，而是交由用户控制

文中主要结合源码分析单例Bean 的生命周期

1. 流程

启动Spring

public class BeanLifecycleAnalyse {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
      
        applicationContext.refresh();
        applicationContext.close();
    }

}

Spring启动要调用ApplicationContent的refresh()方法

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

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                // 初始化单例对象
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

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

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

finishBeanFactoryInitialization内部主要进行Bean初始化相关内容

AbstractApplcationContent#finishBeanFactoryInitialization() 源码

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // Initialize conversion service for this context.
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // 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.
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // Stop using the temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(null);

        // Allow for caching all bean definition metadata, not expecting further changes.
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons.
        // 创建单例Bean
        beanFactory.preInstantiateSingletons();
    }

在 preIntaniateSingletons中会依次按照BeanDefinition的顺序依次初始化Bean
DefaultListableBeanFactory#preIntaniateSingletons() 源码

@Override
    public void preInstantiateSingletons() throws BeansException {
        if (logger.isTraceEnabled()) {
            logger.trace("Pre-instantiating singletons in " + this);
        }

        // 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...
        // 根据BeanDefinition的顺序初始化单例对象
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        final FactoryBean factory = (FactoryBean) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                                            ((SmartFactoryBean) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }

2. AbstractAutowireCapableBeanFactory#createBean()

createBean方法内部就是实例化Bean逻辑的开始

源码中只保留实例化Bean的逻辑

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
        RootBeanDefinition mbdToUse = mbd;
            // ...省略其他代码....

            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
            
            // 实例化Bean
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
                logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
    }

3. 实例化前阶段

源码中 resolveBeforeInstantiation 方法属于实例化前阶段，该阶段会查找Spring中的类型为InstantiationAwareBeanPostProcessor 的BeanPostProcessor，并调用postProcessBeforeInstantiation() 方法进行实例化前置处理

源码

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation()

    protected Object applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

InstantiationAwareBeanPostProcessor 结构

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

    @Nullable
    default Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    
    
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
            throws BeansException {

        return null;
    }

    
    default PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        return pvs;
    }
}

在createBean方法中可以看到，如果该接口的方法返回值不为空，则直接将该对象返回不进行下面的实例化和初始化逻辑，一般该方法用于返回代理对象

4. 实例化阶段

doCreateBean() 源码

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
    
        // ...省略其他代码.....

        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 创建Bean实例
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
    
        // 对Bean进行属性填充
        populateBean(beanName, mbd, instanceWrapper);
        // 初始化Bean
        exposedObject = initializeBean(beanName, exposedObject, mbd);

        return exposedObject;
    }

createBeanInstance会创建Bean实例并返回

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);

        Supplier instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }

        if (mbd.getFactoryMethodName() != null) {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        // 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);
    }

该方法主要确定该调用Bean中的哪个构造方法进行实例化

determineConstructorsFromBeanPostProcessors方法内部会获取类型为SmartInstantiationAwareBeanPostProcessor 的BeanPostProcessor，并执行其determineCandidateConstructors方法, 该方法会返回构造方法数组，实现该接口可以自由选取使用哪个构造方法

4. 属性填充

populateBean方法内部会将Bean的属性进行完善

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        
        // ... 省略其他代码。。。。。

        // 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.
        // 实例化后置处理
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        return;
                    }
                }
            }
        }

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

        PropertyDescriptor[] filteredPds = null;
        if (hasInstAwareBpps) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            
            // 属性处理
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        if (filteredPds == null) {
                            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                        }
                        pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvsToUse == null) {
                            return;
                        }
                    }
                    pvs = pvsToUse;
                }
            }
        }

        if (pvs != null) {
            // 属性填充
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }

  1. 属性填充前

    属性填充前进行 实例化后置处理 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
    调用 InstantiationAwareBeanPostProcessor#postProcessProperties 对属性进行定制操作

  2. 属性填充

    执行applyPropertyValues 内部实际调用的字段的setter方法进行变量赋值

5. 初始化

初始化逻辑在initializeBean() 方法中

源码

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        
        // 回调Aware接口
        invokeAwareMethods(beanName, bean);
        
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            // BeanPostProcessor 初始化前置处理
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            // 执行初始化方法
            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()) {
            // BeanPostProcessor初始化后置处理
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
}

通过源码可以看到初始化分为三个阶段 初始化前，初始化，初始化后

  1. 初始化前

    初始化前执行 invokeAwareMethods方法来回调各个Aware接口的方法，并进行前置处理

    invokeAwareMethods 源码

    private void invokeAwareMethods(final String beanName, final Object bean) {
     if (bean instanceof Aware) {
         if (bean instanceof BeanNameAware) {
             ((BeanNameAware) bean).setBeanName(beanName);
         }
         if (bean instanceof BeanClassLoaderAware) {
             ClassLoader bcl = getBeanClassLoader();
             if (bcl != null) {
                 ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
             }
         }
         if (bean instanceof BeanFactoryAware) {
             ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
         }
     }
}

    Spring中一共有九个Aware接口，这里的方法只会执行前三个，后续的六个在前置处理applyBeanPostProcessorsBeforeInitialization方法中

    applyBeanPostProcessorsBeforeInitialization源码

    @Override
 public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
         throws BeansException {

     Object result = existingBean;
     for (BeanPostProcessor processor : getBeanPostProcessors()) {
         Object current = processor.postProcessBeforeInitialization(result, beanName);
         if (current == null) {
             return result;
         }
         result = current;
     }
     return result;
}

    通过对这段代码debug，可以看到Spring内置了六个BeanPostProcessor，其中剩下六个Aware接口的回调都由第一个ApplicationContextAwareProcessor处理

    ApplicationContextAwareProcessor 源码

    class ApplicationContextAwareProcessor implements BeanPostProcessor {

 private final ConfigurableApplicationContext applicationContext;

 private final StringValueResolver embeddedValueResolver;


 /**
  * Create a new ApplicationContextAwareProcessor for the given context.
  */
 public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
     this.applicationContext = applicationContext;
     this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
 }


 @Override
 @Nullable
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
        // ...省略其他代码...
     invokeAwareInterfaces(bean);

     return bean;
 }

 private void invokeAwareInterfaces(Object bean) {
     if (bean instanceof EnvironmentAware) {
         ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
     }
     if (bean instanceof EmbeddedValueResolverAware) {
         ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
     }
     if (bean instanceof ResourceLoaderAware) {
         ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
     }
     if (bean instanceof ApplicationEventPublisherAware) {
         ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
     }
     if (bean instanceof MessageSourceAware) {
         ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
     }
     if (bean instanceof ApplicationContextAware) {
         ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
     }
 }

}

    通过源码可以看出来在前置处理方法postProcessBeforeInitialization中会依次调用六个Aware接口进行回调

    BeanProcessor集合中还有一个CommonAnnotationBeanPostProcessor类，在这个类中的前置方法处理还会调用注解@PostConstruct标注的方法

  2. 初始化阶段

    初始化会依次调用InitializingBean#afterPropertiesSet 方法和自定义的initMethod

    invokeInitMethods 源码

    protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
         throws Throwable {

     boolean isInitializingBean = (bean instanceof InitializingBean);
     if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
         if (logger.isTraceEnabled()) {
             logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
         }
         
            // 如果实现InitializingBean接口，此处会回调afterPropertiesSet方法
         ((InitializingBean) bean).afterPropertiesSet();
     }

     // 执行initMethod
     if (mbd != null && bean.getClass() != NullBean.class) {
         String initMethodName = mbd.getInitMethodName();
         if (StringUtils.hasLength(initMethodName) &&
                 !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                 !mbd.isExternallyManagedInitMethod(initMethodName)) {
             invokeCustomInitMethod(beanName, bean, mbd);
         }
     }
 }
  1. 初始化后阶段

执行BeanPostProcessor的后置处理

applyBeanPostProcessorsAfterInitialization源码

@Override
 public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
         throws BeansException {

         // 初始化后置处理
     Object result = existingBean;
     for (BeanPostProcessor processor : getBeanPostProcessors()) {
         Object current = processor.postProcessAfterInitialization(result, beanName);
         if (current == null) {
             return result;
         }
         result = current;
     }
     return result;
 }

这一阶段会依次执行各个BeanPostProcessor的后置处理方法postProcessAfterInitialization，通过实现该接口可以实现对Bean的自定义处理

6.所有Bean初始化后

在所有的Bean都经历过上述过程后，Bean已经初始化完成，所有的Bean都已经准备好使用

此时在DefaultListableBeanFactory#preInstantiateSingletons中会进行最后一步回调


    public void preInstantiateSingletons() throws BeansException {
        
        // ....省略实例化和初始化代码
        
        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction) () -> {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }



源码中会循环已经初始化完成的Bean，如果该Bean实现了SmartInitializingSingleton接口则进行afterSingletonsInstantiated方法的回调


这一步和上述初始化流程不同，初始化时是挨个实例化Bean并初始化。这一步是等待所有Bean全部初始化完成，所有Bean都已经是可使用的状态


实现这一接口可以对Bean进行最后的定制操作或其他操作


7.销毁阶段


在Spring应用上下文关闭时，会对Spring中的对象依次进行销毁


销毁操作在 DisposableBeanAdapter#destroy 方法中


源码


    public void destroy() {
        
        // 销毁前置处理
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
            for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
                processor.postProcessBeforeDestruction(this.bean, this.beanName);
            }
        }

        if (this.invokeDisposableBean) {
            try {
                // 执行接口销毁方法
                ((DisposableBean) this.bean).destroy();
            }
        }

        if (this.destroyMethod != null) {
            // 执行自定义destroyMethod
            invokeCustomDestroyMethod(this.destroyMethod);
        }
        else if (this.destroyMethodName != null) {
            Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
            if (methodToInvoke != null) {
                invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
            }
        }
    }



销毁流程和初始化流程类似 分为销毁前和销毁阶段


    

  1.  
    销毁前
     
    调用DestructionAwareBeanPostProcessor#destroy 方法，进行前置处理，被@PreDestroy标注的方法也会在这一阶段由CommonAnnotationBeanPostProcessor#postProcessBeforeDestruction 方法执行(该方法由其父类InitDestroyAnnotationBeanPostProcessor实现)
     
    2. 

  2.  
    销毁阶段
     
    如果Bean实现了DestructionAwareBeanPostProcessor接口，则调用其destroy方法
     
    如果指定了Bean的destroyMethod则执行其销毁方法
     
    3. 



总结


Bean生命周期流程


    

  •  
    Bean实例化阶段 AbstractAutowireCapableBeanFactory#createBeanInstance
     
    实例化前：InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 前置处理
     
    实例化：AbstractAutowireCapableBeanFactory#createBeanInstance 创建Bean实例
     
    • 

  •  
    Bean属性填充阶段 AbstractAutowireCapableBeanFactory#populateBean
     
    属性填充前：InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation 后置处理
     InstantiationAwareBeanPostProcessor#postProcessProperties 属性处理
     
    属性填充：AbstractAutowireCapableBeanFactory#applyPropertyValues 属性设置
     
    • 

  •  
    Bean实例化阶段 AbstractAutowireCapableBeanFactory#initializeBean
     
    实例化前：AbstractAutowireCapableBeanFactory#invokeAwareMethods Aware接口回调，
     @PostConstruct方法调用
     
    实例化：AbstractAutowireCapableBeanFactory#invokeInitMethods 初始化方法回调
     InitializingBean#afterPropertiesSet，initMethod
     
    实例化后：SmartInitializingSingleton#afterSingletonsInstantiated 实例化后回调
     
    • 

  •  
    销毁阶段 DisposableBeanAdapter#destroy
     
    销毁前：DestructionAwareBeanPostProcessor#postProcessBeforeDestruction 销毁前置处理，
     @PreDestroy 方法回调
     
    销毁：执行销毁方法 DisposableBean#destroy，destroyMethod
     
    • 

























你可能感兴趣的:(Spring Bean 生命周源码解析)






    

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

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

    • 

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

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

    • 

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

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

    • 

  • 30天风格练习-DAY2
黄希夷

    Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
    

    • 

  • 向内而求
陈陈_19b4

    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    

    • 

  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
成长时间线

    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    

    • 

  • 蘩漪：新女性？利己主义者
赮_红雨

    蘩漪是曹禺《雷雨》笔下的女性形象。对于她的喜爱，曹禺在之前的访谈中，就已经表达得很清楚了，蘩漪是他所倾心的女子的“代替者”。在这个女性身上有着曹禺最精心的描写，但同时她的身上又存在着一些时代的问题。图片发自App首先，繁漪是追求自由和幸福的新女性形象。她是精神悲剧的核心人物，她对周朴园的反抗，具有典型意义。她是位资产阶级家庭出身的小姐，受过五四新思潮的影响，她任性、傲慢，追求人格独立、个性自由和爱
    

    • 

  • 读《人世间》有感
一0一

    这个寒假，就如同朋友圈中的一段话：一闭眼，一睁眼假期还有5天，在一闭眼一睁眼假期还有12天；再一闭眼一睁眼假期还有20天；不敢睡，不敢睡啊……受疫情影响，这个假期变得漫长又煎熬，我也无时无刻不关注着疫情的变化。当然这样的一个假期，我还真得要感谢周翔，因为他有个爱看书的习惯，所以家里有不少他看过的书，可以让我随意挑选，因此也让我的假期不至于那么无所事事。这次我选了一本梁晓声的《人世间》，作为一名语文
    

    • 

  • 运城寻访重逢石头纪实【严建设老照片395 集】 我简直能把你想透， 当我走进运城的时候。 我已急得热汗直流， 访问了十九个老头， 把晋南的小城转了三周。 虽然是悠久的思旧， 我仍然是牛样的执...
严建设

    运城寻访重逢石头纪实【严建设老照片395集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执拗。说什么变换的世情，泛起了过去的逝流，你就是真正的故友。踏破铁鞋的淡愁，已化为不废功夫的范畴，是就像远在天涯近在咫尺，就像是梦乡的邂逅，我紧紧地攥着你的手。你已长成了高高的个头，俊逸的容颜却很清瘦，你那样顽皮的童音，已变到老
    

    • 

  • 2023-04-17|篮球女孩
长一木

    1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
    

    • 

  • 高端密码学院笔记285
柚子_b4b4

    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    

    • 

  • 阶段总结反思
轻争

    马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
    

    • 

  • 心有蓝天白云，爱情便会晴空万里，然后有花香有鸟鸣有美好的未来
曹十二吖

    丁南的婚姻，来自于一场她对生命的对比。她曾经说过，当她最爱的母亲用生命去逼迫她结婚的时候，她曾一度不理解到愤怒，甚至于想过用轻生来对抗母亲的不理智。庆幸的是，丁南是一个自我调节能力非常强的人，她想如果我连死亡都不怕，还怕不能经营好一段婚姻吗？抱着这样的念头，24年没有谈过恋爱的她，用短短三个月的时间，完成了少女到女人的蜕变。她曾经说过：“我要把自己最珍贵的东西留给自己命中注定的那个人。”闺蜜几人中
    

    • 

  • 展现思维导图魅力，不断挖掘人生宝藏
思维导图讲师Mandy

    第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
    

    • 

  • C++菜鸟教程 - 从入门到精通 第二节
DreamByte
c++

    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
    

    • 

  • 《在战“疫”中成长致敬生活》观后感
梅子刘的刀

    （作者：周晨）今天上午，我看了“我是接班人”网络大课堂《在战役中成长致敬生活》。有很多人拿出自己攒下的钱，默默地捐给了武汉，有几千块钱的、有几万块钱的，也有十几万块钱的。连小朋友也把自己的压岁钱捐给了武汉。有名环卫工人把自己五年的积蓄全部捐给了武汉。有名外卖小哥为医护人员买鞋子送吃的。还有已经治愈出院的新型肺炎病人捐了400毫升的血浆。还有位叫大树的叔叔，虽然他没有钱，但是他地里有蔬菜，捐了几大卡
    

    • 

  • 2019-10-24
柒月的可可

    今日上班无事，人又懒怠动，不知道如何打发这个下午，终于打开了。我大概是把当日记来写的。重庆的天气骤然凉了。早上出门的时候，满地都是落叶，脚踩上去，却是刚下过雨，叶子已润掉，走不出声响。白天在办公室不见天日，对温度也无甚感觉，晚上一个人回到家，屋子里窗户都开着，被冷风吹了一天，一迈进屋，便觉冷气森然。将近二十度的天气，竟要裹着毯子才觉温暖。再过一周，就到十一月。扛过十一月，就可以开暖气了。然而我真的
    

    • 

  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
文章永久免费只为良心
oracle数据库

    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    

    • 

  • 读书为什么这么难，听拆书帮赵周怎么说。
董小萌读书

    赵周的《这样读书就够了》提炼了成年人读书难的三个问题。问题一：没时间、没精力这是压力与学习的矛盾问题二：看不懂、记不住这是搞错了学习主体其实，我们大多数人在学习主体是谁的问题一直都很模糊。问题三：看不下去这是学习目的不明确，说白了就是不知道为啥而看。也许你会觉得这话有点一竿子打死一片的劲头。不急着反驳，可以回忆一下，哪本书，哪类书，是你曾经读完了，并在脑海中至今还留下痕迹的？是的。成年人的读书，是
    

    • 

  • 大雄的新恐龙：养育生命，的确不易
沧浪先生

    哆啦A梦这个动画片，我小时候没有看过，长大了之后似乎对这种充满童真童趣的动画片也没有太多的喜爱，所以结果很明显，我并没有看过哆啦A梦这个动画片。但是近年来大屏幕的兴起，让各家影视剧制作者发现了电影化的好处，没错，电影不仅影响力更大，钱赚得也多。《哆啦A梦·大雄的新恐龙》是最新的一部大屏幕电影，大雄和柯南一样，都永远长不大，而且他和他的小伙伴日复一日、年复一年地和机器猫哆啦A梦在一起玩耍，永远的神奇
    

    • 

  • 生命如花
坦释空

    每个人的心中都有一株妙莲花。这是禅家语。禅家总是站在理性的高处，以超越红尘的洒脱来参悟人生和自省生命。那么，凡俗中人呢？生如夏花之绚丽，死如秋叶之静美。这是诗人语。多少人在赞美：姑娘好像花一样！又有多少人在咏歌：花儿与少年。的确，人生如花。花一样的生命，理应自诞生之日起，就一瓣一瓣地绽放她的美丽与清香，使这个原本死寂荒凉的世界五彩缤纷，充满快乐。事实上，人类自诞生起，就一代一代地做着这方面的努力，
    

    • 

  • 2023.5.10 周三 早7:38
努力逆流而上

    榜样的力量前一段时间追一个《一生一世》的电视剧，脑残剧，但居中的周生辰，稳重。润玉一般的性格，坚持着10年如一日的自律习惯，养成的性格也是这样温文尔雅，虽然是剧中塑造，但我感觉现实中一定是有的，让我觉得人生就是这样的修行，自律不是强迫自己，是形成的习惯，坚持的习惯！结果五一回家，太无聊，看了韩剧的《继承者》让孩子也跟着一起看手机，昨天跑了步，但发现没有很快乐，不知道起的太晚还是怎么着，7点的大街上
    

    • 

  • 我与《红楼梦》‖纪念曹雪芹出生307周年！归海逸舟是周成功子阳佳乐
归海逸舟是周成功子阳佳乐

    【今日作家推荐】中国古典小说之首《红楼梦》，其作者曹雪芹是文坛泰斗。约1715年5月28日，曹雪芹出生。所以，今天推荐的是中国人众所周知的作家——曹雪芹。曹雪芹在世界读者心目中也影响广大，可以与西方世界引以为豪的莎士比亚、歌德等媲美。1、我与《红楼梦》我一直想写一篇和《红楼梦》相关的文章，现在机会终于来了！《红楼梦》作为我国家喻户晓的文学名著，其影响是空前的。还在我很小的时候，姥姥经常讲《红楼梦》
    

    • 

  • 2019考研 | 西交大软件工程
笔者阿蓉

    本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
    

    • 

  • 张芝华49天共修 - 草稿
李娟AINI

    祈禱、靜心、源代碼編程、觀想發願四根支柱，運用靈性能量的助力，讓夢想和渴望在最大向度中輕鬆實現。共修群指定书籍:1.能断金刚麦克格西2.新世界：灵性的觉醒埃克哈特·托尔3.爱是一切的答案芭芭拉迪安吉莉思4.完美的爱,不完美的关系约翰•威尔伍德5.爱的业力法则麦克格西6.漫画《金刚经》蔡志忠7.蔡志忠典藏国学漫画系列(套装共6册)作业:全部在共修群里完成，并请保存好自己的作业。l一周三次共修觉察作业
    

    • 

  • 今日有感，坚持分享第913天，2019.07.13
ZAF峰回路转

    本周是假日里最忙碌的一周，连续四天晚上的课程，让我感觉到身体明显透支。昨天晚上读书会结束回到家，已经是十点半之后啦，忽然感觉身体不舒服，勉强支撑着洗漱完毕，没等上床休息，强烈的不适感警告我该吃药啦！感谢老公半夜到医院給我抓了药，今天早上当我对老公表达谢意的时候，老公说，不用感谢，我不是一直都是这样做的吗？多少年啦，今天竟然还谢谢！老公说的没错，可是以前总感觉那是他应该做的，如今感觉到，身边有一个在
    

    • 

  • spring如何整合druid连接池？
惜.己
springspringjunit数据库javaidea后端xml

    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    

    • 

  • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    

    • 

  • 准备
胡珊珊乐平九小

    尊敬的各位领导、各位同仁们：大家上午好！我是来自乐平九小的胡珊珊。今天很高兴能有机会给大家做“智慧作业”应用培训。说到“智慧作业”我感触颇多，我是在智慧作业中成长起来的，我也时常以自己是一名“智慧作业人”自居。早在2020年疫情期间，学校电教处周光杰主任在学校群里发出智慧作业抢题通知，我看了有些心动，一节微课相当于一次省级公开课，这对于我们普通老师是多么难得的机会啊。但想归想，我也不会用软件啊，再
    

    • 

  • ❤学习《家庭教育指导师》第三天分享❤
温暖富足女神

    时光飞逝，转眼来到了第3天的学习，今天上午的领导讲话与故事分享时间虽然有点长，但却带给大家很大的启发：亲人的离世，让我们更加珍惜身边的眼前人;导师们的心历路程让我们感动、敬佩与深受启发！每个人的生命都是独一无二的，每个人的生命都那么的珍贵与精彩！每个人的生命又那么的不容易与耐抗挫折！每个人来到这个人世间，都会有它的使命感，当强大的内心力量被唤醒时，他将无所不能！慧萍老师带我们体验的“一分钟击掌”与
    

    • 

  • jquery实现的jsonp掉java后台
知了ing
javajsonpjquery

     什么是JSONP？
先说说JSONP是怎么产生的：
其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。
1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准；
2、
    

    • 

  • Struts2学习笔记
caoyong
struts2

    SSH : Spring + Struts2 + Hibernate
三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller)
分层原则:单向依赖，接口耦合
1、Struts2  =  Struts  + Webwork
2、搭建struts2开发环境
   a>、到www.apac
    

    • 

  • SpringMVC学习之后台往前台传值方法
满城风雨近重阳
springMVC

    springMVC控制器往前台传值的方法有以下几种：
1.ModelAndView
   通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参：
   
 ModelAndView mv=new ModelAndView();
 mv.setViewName="success
    

    • 

  • WebService存在的必要性？
一炮送你回车库
webservice

    做Java的经常在选择Webservice框架上徘徊很久，Axis  Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。
是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。
当在不同的平台间传输数据时，就需要一个都能解析的数据格式。
但是为什么要使用xml呢？不能使json或者其他通用数据
    

    • 

  • js年份下拉框
3213213333332132
java web ee

    
<div id="divValue">test...</div>测试
//年份
<select id="year"></select>
<script type="text/javascript">
window.onload = 
    

    • 

  • 简单链式调用的实现技术
归来朝歌
方法调用链式反应编程思想

    在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用
这样的调用你可能在Ajax中，在页面中添加标签：
$("<p>").append($("<span>").text(list[i].name)).appendTo("#result");
 
也可能在HQ
    

    • 

  • JAVA调用.net 发布的webservice 接口
darkranger
webservice

     /**
* @Title: callInvoke
* @Description: TODO(调用接口公共方法)
* @param @param url 地址
* @param @param method 方法
* @param @param pama 参数
* @param @return
* @param @throws BusinessException 
    

    • 

  • Javascript模糊查找 | 第一章 循环不能不重视。
aijuans
Way

     最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下：
function search(){
var arr=new Array("my
    

    • 

  • 狼和羊，该怎么抉择
atongyeye
工作

    狼和羊，该怎么抉择
在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。
今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
    

    • 

  • 读取android系统的联系人拨号
百合不是茶
androidsqlite数据库内容提供者系统服务的使用

     
     联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢
 
关键代码:
 
 
1, 使用javabean操作存储读取到的数据
package com.example.bean;
/**
*
* @author Admini
    

    • 

  • ORACLE自定义异常
bijian1013
数据库自定义异常

    实例：
CREATE OR REPLACE PROCEDURE test_Exception
(
ParameterA IN varchar2,
ParameterB IN varchar2,
ErrorCode OUT varchar2 --返回值,错误编码
)
AS
/*以下是一些变量的定义*/
V1 NUMBER;
V2 nvarc
    

    • 

  • 查看端号使用情况
征客丶
windows

    一、查看端口
在windows命令行窗口下执行：
>netstat -aon|findstr "8080"
显示结果：
TCP     127.0.0.1:80         0.0.0.0:0    &
    

    • 

  • 【Spark二十】运行Spark Streaming的NetworkWordCount实例
bit1129
wordcount

    Spark Streaming简介
  NetworkWordCount代码
 
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with

    

    • 

  • Struts2 与 SpringMVC的比较
BlueSkator
struts2spring mvc

    1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
    

    • 

  • Hibernate在更新时，是可以不用session的update方法的(转帖）
BreakingBad
Hibernateupdate

    地址：http://blog.csdn.net/plpblue/article/details/9304459
public void synDevNameWithItil()
{Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
    

    • 

  • 读《研磨设计模式》-代码笔记-观察者模式
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
/**
* “观
    

    • 

  • 重置MySQL密码
chenhbc
mysql重置密码忘记密码

    如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）：
1、关闭MySQL服务
2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL
mysqld --skip-grant-tables
 3、新开一个CMD窗口，进入MySQL
mysql -uroot
 
    

    • 

  • 再谈系统论，控制论和信息论
comsci
设计模式生物能源企业应用领域模型

    
                           再谈系统论，控制论和信息论
    偶然看
    

    • 

  • oracle moving window size与 AWR retention period关系
daizj
oracle

    转自： http://tomszrp.itpub.net/post/11835/494147
晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程.
SQL> select * from v$version;
BANNER
-------------------
    

    • 

  • Python版B树
dieslrae
python

    话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树...
首先是数据实体对象,很简单,只存放key,value
class Entity(object):
'''数据实体'''
def __init__(self,key,value)
    

    • 

  • C语言冒泡排序
dcj3sjt126com
算法

    代码示例：
# include <stdio.h>
//冒泡排序
void sort(int * a, int len)
{
int i, j, t;
for (i=0; i<len-1; i++)
{
for (j=0; j<len-1-i; j++)
{
if (a[j] > a[j+1]) // >表示升序 
    

    • 

  • 自定义导航栏样式
dcj3sjt126com
自定义

    -(void)setupAppAppearance
{
[[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]];
[UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
    

    • 

  • 11.性能优化-优化-JVM参数总结
frank1234
jvm参数性能优化

    1.堆
-Xms --初始堆大小
-Xmx --最大堆大小
-Xmn --新生代大小
-Xss --线程栈大小
-XX:PermSize  --永久代初始大小
-XX:MaxPermSize  --永久代最大值
-XX:SurvivorRatio --新生代和suvivor比例,默认为8
-XX:TargetSurvivorRatio --survivor可使用
    

    • 

  • nginx日志分割 for linux
HarborChung
nginxlinux脚本

    nginx日志分割 for linux 默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本   使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限
 
复制代码代码如下:
chmo
    

    • 

  • Spring4新特性——泛型限定式依赖注入
jinnianshilongnian
springspring4泛型式依赖注入

    Spring4新特性——泛型限定式依赖注入
Spring4新特性——核心容器的其他改进
Spring4新特性——Web开发的增强
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC 
Spring4新特性——Groovy Bean定义DSL
Spring4新特性——更好的Java泛型操作API 
Spring4新
    

    • 

  • centOS安装GCC和G++
liuxihope
centosgcc

    Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。
按照这个思路，我想安装过程如下：
安装gcc：yum install gcc
安装g++： yum install g++
实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
    

    • 

  • 第13章 Ajax进阶（上）
onestopweb
Ajax

    index.html
<!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/
    

    • 

  • How to determine BusinessObjects service pack and fix pack
blueoxygen
BO

    http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/
 
The table below is helpful. Reference
  BOE XI 3.x
12.0.0.
y BOE XI 3.0 12.0.
x.
y BO
    

    • 

  • Oracle里的自增字段设置
tomcat_oracle
oracle

    　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no 　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列
create table t
(
id 　　 　　 number generated by default as identity (start with 1 increment b
    

    • 

  • Spring Security（01）——初体验
yang_winnie
springSecurity

    Spring Security（01）——初体验
    博客分类： spring Security
Spring Security入门安全认证
       首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置
    

    •