Spring 容器对于 Bean 生命周期处理

Spring Bean 生命周期记录

version：Spring Framework 5.3.x

Overview

BeanDefinition

BeanDefinition（see）封装了Bean的配置信息（提供一系列Getter、Setter方法），包括Class、Scope、FactoryBean信息、构造器参数、是否懒加载、初始化方法、销毁方法等，Spring是根据BeanDefinition的信息创建Bean。

https://docs.spring.io/spring...

BeanFactory

Spring IoC底层容器，Spring IoC的基础。有很多的子类（大体上可以根据命名看出功能），基本上都用DefaultListableBeanFactory。（see）

https://docs.spring.io/spring...

ApplicationContext

更高级的Ioc容器，内部其实还是使用了BeanFactory做Bean的管理，只不过ApplicationContext提供了更多功能（比如BeanFactoryPostProcessor（BeanFactoryPostProcessor在BeanFactory级别是没有的）&BeanPostProcessor自动注入、Spring 消息、Spring 事件等）（see）

https://docs.spring.io/spring...

BeanPostProcessor

Bean回调接口。基于它和一系列子类实现了生命周期的各种操作。根据注释，非代理类通常通过postProcessBeforeInitialization回调，而代理类则通过postProcessAfterInitialization（BeanFactory创建的Bean只会调这个方法）。另外BeanPostProcessor的顺序很重要，它仅支持PriorityOrdered、Ordered接口排序，不支持@Order注解。

/**
 * Factory hook that allows for custom modification of new bean instances —
 * for example, checking for marker interfaces or wrapping beans with proxies.
 *
 * 
Typically, post-processors that populate beans via marker interfaces
 * or the like will implement {@link #postProcessBeforeInitialization},
 * while post-processors that wrap beans with proxies will normally
 * implement {@link #postProcessAfterInitialization}.
 *
 * 
Registration

 * 
An {@code ApplicationContext} can autodetect {@code BeanPostProcessor} beans
 * in its bean definitions and apply those post-processors to any beans subsequently
 * created. A plain {@code BeanFactory} allows for programmatic registration of
 * post-processors, applying them to all beans created through the bean factory.
 *
 * 
Ordering

 * 
{@code BeanPostProcessor} beans that are autodetected in an
 * {@code ApplicationContext} will be ordered according to
 * {@link org.springframework.core.PriorityOrdered} and
 * {@link org.springframework.core.Ordered} semantics. In contrast,
 * {@code BeanPostProcessor} beans that are registered programmatically with a
 * {@code BeanFactory} will be applied in the order of registration; any ordering
 * semantics expressed through implementing the
 * {@code PriorityOrdered} or {@code Ordered} interface will be ignored for
 * programmatically registered post-processors. Furthermore, the
 * {@link org.springframework.core.annotation.Order @Order} annotation is not
 * taken into account for {@code BeanPostProcessor} beans.
 *
 * @author Juergen Hoeller
 * @author Sam Brannen
 * @since 10.10.2003
 * @see InstantiationAwareBeanPostProcessor
 * @see DestructionAwareBeanPostProcessor
 * @see ConfigurableBeanFactory#addBeanPostProcessor
 * @see BeanFactoryPostProcessor
 */
public interface BeanPostProcessor {

    /**
     * Apply this {@code BeanPostProcessor} to the given new bean instance before any bean
     * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
     * or a custom init-method). The bean will already be populated with property values.
     * The returned bean instance may be a wrapper around the original.
     * 
The default implementation returns the given {@code bean} as-is.
     * @param bean the new bean instance
     * @param beanName the name of the bean
     * @return the bean instance to use, either the original or a wrapped one;
     * if {@code null}, no subsequent BeanPostProcessors will be invoked
     * @throws org.springframework.beans.BeansException in case of errors
     * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
     */
    //初始化前回调方法
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    /**
     * Apply this {@code BeanPostProcessor} to the given new bean instance after any bean
     * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
     * or a custom init-method). The bean will already be populated with property values.
     * The returned bean instance may be a wrapper around the original.
     * 
In case of a FactoryBean, this callback will be invoked for both the FactoryBean
     * instance and the objects created by the FactoryBean (as of Spring 2.0). The
     * post-processor can decide whether to apply to either the FactoryBean or created
     * objects or both through corresponding {@code bean instanceof FactoryBean} checks.
     * 
This callback will also be invoked after a short-circuiting triggered by a
     * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
     * in contrast to all other {@code BeanPostProcessor} callbacks.
     * 
The default implementation returns the given {@code bean} as-is.
     * @param bean the new bean instance
     * @param beanName the name of the bean
     * @return the bean instance to use, either the original or a wrapped one;
     * if {@code null}, no subsequent BeanPostProcessors will be invoked
     * @throws org.springframework.beans.BeansException in case of errors
     * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
     * @see org.springframework.beans.factory.FactoryBean
     */
    //初始化后回调方法
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

InstantiationAwareBeanPostProcessor

在BeanPostProcessor基础上增加了几个方法，以名字而言应该是跟初始化有关。很多类都基于它实现，比如@Autowired、@Value注解能力的AutowiredAnnotationBeanPostProcessor，提供JSR-250注解能力的CommonAnnotationBeanPostProcessor等。

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

//PS:个人感觉以下两个方法跟实例化没啥关系跟初始化有点关系，不过此类又是继承BeanPostProcessor，其实还是有点关系，只不过名字感觉怪怪的。（仁者见仁智者见智吧。）
//用于Bean的属性填充，返回null时跳过填充
   @Nullable
   default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
         throws BeansException {

      return null;
   }

//用于Bean的属性填充，返回null时跳过填充（虽然标记为过时，但Spring其实会在postProcessProperties返回null时调用，只有当这两个方法都为null时才跳过属性填充（未来应该会删除））
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        return pvs;
    }

}

BeanWrapper

BeanWrapper是Spring底层JavaBeans基础的中央接口（基于javabeans规范，包装了Bean对象，使用java.beans API进行属性相关操作），通常用于数据绑定和BeanFactory中。

https://docs.spring.io/spring...

Lifecycle

以ApplicationContext作为IoC容器记录一下Bean的生命周期。之所以不用BeanFactory是因为有部分环节只在ApplicationContext为容器才能体现（比如CommonAnnotationBeanPostProcessor、ApplicationContext级别的Aware接口等），而且大部分项目都是使用ApplicationContext，很少直接使用BeanFactory。不过虽说使用了ApplicationContext，但其实大部分过程都是在DefaultListableBeanFactory中。

使用下面类跟踪，具体调用链可以从AbstractBeanFactory#getBean(String name)方法进入 
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValue;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import java.beans.PropertyDescriptor;
import java.util.function.Supplier;

public class LifecycleMain {

    private static int COUNT = 1;

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(LifecycleMain.class);
//        applicationContext.getBeanFactory().addBeanPostProcessor(new CustomBeanPostProcessor()); //若通过直接注册优先级最高,使用不当会引起一些注解注入失效等问题
//        applicationContext.registerBean(BeanDomain.class, BeanDomain::new, (bd) -> bd.setInitMethodName("initMethod"));
        applicationContext.refresh();
        BeanDomain beanDomain = applicationContext.getBean(BeanDomain.class);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        printlnFormatMessage(beanDomain.stringFiled);
        applicationContext.close();
    }

    @Bean
    public CustomBeanPostProcessor customInstantiationAwareBeanPostProcessor() {
        return new CustomBeanPostProcessor();
    }


    public static class CustomBeanPostProcessor implements InstantiationAwareBeanPostProcessor,
            MergedBeanDefinitionPostProcessor, //若不实现它，则属性注入以及@PostConstruct会失效，当然注意实现的方法的返回也可以规避这些问题
            PriorityOrdered {

        @Override
        public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
            if (isBeanDomain(beanClass)) {
                printlnFormatMessage("InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation");
//                return null; //返回null会终止实例化并进入初始化后阶段
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInstantiation(beanClass, beanName);
        }

//        @Override
        public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
            if (isBeanDomain(beanType)) {
                printlnFormatMessage("MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition");
            }
        }

        @Override
        public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
            if (isBeanDomain(bean.getClass())) {
                printlnFormatMessage("InstantiationAwareBeanPostProcessor#postProcessProperties");
                return null; //返回null终止属性注入，若此InstantiationAwareBeanPostProcessor优先级较高，会出现一些注解注入失效问题
            }
            return pvs;
        }

        @Override
        public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
            if (isBeanDomain(bean.getClass())) {
                return null; //返回null终止属性注入，若此InstantiationAwareBeanPostProcessor优先级较高，会出现一些注解注入失效问题
            }
            return pvs;
        }

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if (isBeanDomain(bean.getClass())) {
                printlnFormatMessage("BeanPostProcessor#postProcessBeforeInitialization");
                return null; //返回null 后续postProcessBeforeInitialization终止
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
        }

        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if (isBeanDomain(bean.getClass())) {
                printlnFormatMessage("BeanPostProcessor#postProcessAfterInitialization");
                return null; //返回null 后续postProcessAfterInitialization终止
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
        }

        @Override
        public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
            if (isBeanDomain(bean.getClass())) {
                printlnFormatMessage("InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation");
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessAfterInstantiation(bean, beanName);
        }



        @Override
        public int getOrder() {
            return Ordered.LOWEST_PRECEDENCE;
        }
    }

    @Bean
    public String stringFiled() {
        return "stringFiled";
    }


    @Bean(initMethod = "customInitMethod", destroyMethod = "customDestroyMethod")
//    @Scope(SCOPE_PROTOTYPE) //不会有完成阶段以及销毁阶段
//    @Lazy //不会有完成阶段
    public BeanDomain beanDomain() {
        return new BeanDomain();
    }

    public static class BeanDomain implements InitializingBean, DisposableBean,
            BeanFactoryAware, ApplicationContextAware, SmartInitializingSingleton {

        //@Resource
        @Autowired
        @Qualifier("stringFiled")
        private String stringFiled = "lueluelue";

        public BeanDomain() {
        }

        @PostConstruct
        public void initPostConstruct() {
            printlnFormatMessage("PostConstruct");
        }

        @PreDestroy
        public void preDestroy() {
            printlnFormatMessage("preDestroy");
        }

        @Override
        public void afterPropertiesSet() throws Exception {
            printlnFormatMessage("InitializingBean#afterPropertiesSet");
        }

        @Override
        public void destroy() throws Exception {
            printlnFormatMessage("DisposableBean#destroy");
        }

        public void customInitMethod() {
            printlnFormatMessage("customInitMethod");
        }

        public void customDestroyMethod() {
            printlnFormatMessage("customDestroyMethod");
        }

        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            printlnFormatMessage("BeanFactoryAware#setBeanFactory");
        }

        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            printlnFormatMessage("ApplicationContextAware#setApplicationContext");
        }

        @Override
        public void afterSingletonsInstantiated() {
            printlnFormatMessage("SmartInitializingSingleton#afterSingletonsInstantiated");
        }
    }

//    @Bean
//    public BeanDomainFactoryBean beanDomainFactoryBean() {
//        return new BeanDomainFactoryBean();
//    }
//    
//    //通过FactoryBean创建的Bean只会调用BeanPostProcessor#postProcessAfterInitialization
//    public static class BeanDomainFactoryBean implements FactoryBean {
//
//        @Override
//        public BeanDomain getObject() throws Exception {
//            return new BeanDomain();
//        }
//
//        @Override
//        public Class getObjectType() {
//            return BeanDomain.class;
//        }
//    }

    private static boolean isBeanDomain(Class clazz) {
        return BeanDomain.class.equals(clazz);
    }

    private static void printlnFormatMessage(String message) {
        System.out.println(String.format("%s. %s", COUNT++, message));
    }
}

BeanDefinition 注册阶段

方法：BeanDefinitionRegistry#registerBeanDefinition（具体实现看DefaultListableBeanFactory）

将BeanDefinition信息注册到Ioc容器中，供后面Bean创建使用。（至于BeanDefinition信息的来源，主要是Spring内置、注解、XML、配置文件等）

BeanDefinition 合并阶段

方法：AbstractBeanFactory#getMergedLocalBeanDefinition（先从缓存获取，没有才去调getMergedBeanDefinition）

在Bean创建前会经过merge，将子Bean与父Bean合并，最终所有的BeanDefinition都会转换成RootBeanDefinition。（通过createBean调用，而createBean的调用有几种情况，如果是一些内置的组件（比如内置的BeanFactoryPostProcessor），会由ApplicationContext在invokeBeanFactoryPostProcessors时调用，而如果是我们普通的Bean（非懒加载、单例）会由AbstractApplicationContext#finishBeanFactoryInitialization通过DefaultListableBeanFactory.preInstantiateSingletons调用）

Bean 实例化前阶段

方法：AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation

会调用所有的InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation方法，当返回的对象不为null时，会终止Bean的创建并直接返回（可以用于生成代理对象）。同时在触发终止Bean创建后，会进入Bean初始化后阶段，即调用AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization方法。

Bean 实例化阶段

方法：AbstractAutowireCapableBeanFactory#createBeanInstance

根据BeanDefinition中的信息创建Bean实例，最终会返回BeanWrapper。（此时创建的对象并未填充属性）

优先级分别是Supplier方式（obtainFromSupplier）、FactoryMethod方式（instantiateUsingFactoryMethod，@Bean是根据这个方式）、匹配构造器方式（autowireConstructor）、无参构造器方式（instantiateBean）

构造器方式具体的实例化是根据InstantiationStrategy完成的，默认使用CglibSubclassingInstantiationStrategy

/**
 * Simple object instantiation strategy for use in a BeanFactory.
 *
 * 
Does not support Method Injection, although it provides hooks for subclasses
 * to override to add Method Injection support, for example by overriding methods.
 *
 */
public class SimpleInstantiationStrategy implements InstantiationStrategy {
......
}


/**
 * Default object instantiation strategy for use in BeanFactories.
 *
 * 
Uses CGLIB to generate subclasses dynamically if methods need to be
 * overridden by the container to implement Method Injection.
 * 提供了方法注入的支持
 */
public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy {
......
}

BeanDefinition 修改阶段

方法：AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors

通过MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition方法，允许对RootBeanDefinition进行修改。

例如：在CommonAnnotationBeanPostProcessor中会获取@Resource、@PostConstruct、@PreDestroy属性或方法信息并写入到BeanDefinition中，类似的在AutowiredAnnotationBeanPostProcessor中会获取@Autowired、@Value、@Inject属性信息并写入到BeanDefinition中（InjectionMetadata#checkConfigMembers -> BeanDefinition#registerExternallyManagedConfigMember）。

Bean 属性填充阶段

方法：AbstractAutowireCapableBeanFactory#populateBean

大致流程如下：

  1. 实例化后处理

    方法：InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation

    调用所有InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation，让InstantiationAwareBeanPostProcessors 有能力在Bean属性注入前修改Bean状态。返回true代表要进行属性填充，false则不需要。

  1. postProcessProperties（真不知道怎么翻译，直译怪怪的...）

    方法：InstantiationAwareBeanPostProcessor#postProcessProperties和InstantiationAwareBeanPostProcessor#postProcessPropertyValues（过时）

    处理所有的postProcessProperties和postProcessPropertyValues方法。

    先调用一个InstantiationAwareBeanPostProcessor的postProcessProperties方法，如果返回为null，会调用过时的postProcessPropertyValues方法（为了兼容一些旧版本吧，可能在未来会删除这个方法）。当有一个InstantiationAwareBeanPostProcessor的处理结果为null时，会停止属性填充，所以InstantiationAwareBeanPostProcessor的顺序很重要，这里有坑。

    为什么说有坑呢，因为@Resource、@Autowired、@Value、@Inject等注解都是在这一步进行填充，如果我们自定义的InstantiationAwareBeanPostProcessor先于CommonAnnotationBeanPostProcessor（@Resource支持）、AutowiredAnnotationBeanPostProcessor（@Autowired、@Value、@Inject支持）返回null，那么它们的属性填充就会失败了。

    重点类 ：CommonAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor

    以AutowiredAnnotationBeanPostProcessor为例子

    @Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//获取所有的@Autowired、@Value、@Inject InjectionMetadata信息
   InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
   try {
   //根据InjectionMetadata进行注入
      metadata.inject(bean, beanName, pvs);
   }
   catch (BeanCreationException ex) {
      throw ex;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
   }
   return pvs;
}

  1. 属性填充

    方法：AbstractAutowireCapableBeanFactory#applyPropertyValues

    将PropertyValues填充到Bean中，XML方式更加直观。

Bean 初始化阶段

方法：AbstractAutowireCapableBeanFactory#initializeBean

也包含了很多方法的调用，大致如下：

  1. BeanFactory级别的Aware接口回调

    方法：AbstractAutowireCapableBeanFactory#invokeAwareMethods

    private void invokeAwareMethods(String beanName, 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);
      }
   }
}

  1. 初始化前回调

    方法：AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

    循环调用所有的BeanPostProcessor#postProcessBeforeInitialization方法，当返回为null停止调用。

    ApplicationContext级别的Aware接口就是在这个阶段实现的，具体见ApplicationContextAwareProcessor（还要Servlet级别的ServletContextAwareProcessor）。

    此外还有CommonAnnotationBeanPostProcessor支持的@PostConstruct初始化方法也是在这里通过postProcessBeforeInitialization方法进行的。

  1. 初始化

    方法：AbstractAutowireCapableBeanFactory#invokeInitMethods

    包含了InitializingBean的调用以及自定义初始化方法的调用。

    1. 先判断Bean是否InitializingBean，若是则会调用afterPropertiesSet初始化。
    2. 调用BeanDefinition中配置的初始化方法（@Bean配置的，或者XML中配置的）。

Bean 初始化后阶段

方法：AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

与初始前回调类似，循环调用BeanPostProcessor#postProcessAfterInitialization，当返回为null停止调用。在实例化前阶段终止实例化的Bean也会进入此阶段。

Bean 销毁回调注册

方法：AbstractBeanFactory#registerDisposableBeanIfNecessary

针对非Prototype的（因为Prototype作用域的Bean创建完可以说就不归Spring管理了，每次创建都是新的），以及需要销毁的Bean会调用此方法注册一个DisposableBean（使用DisposableBeanAdapter适配）供IoC容器关闭是销毁调用。

关于需要销毁的Bean主要有：

  • 实现了DisposableBean的类
  • 实现了AutoCloseable的类
  • BeanDefinition指定了销毁方法（@Bean配置、XML配置等）
  • 存在DestructionAwareBeanPostProcessor并且该Bean适用于DestructionAwareBeanPostProcessor（举个例子就是BeanFactory的BeanPostProcessor列表存在CommonAnnotationBeanPostProcessor，并且我们的Bean使用了@PreDestroy指定销毁方法）

具体看AbstractBeanFactory#requiresDestruction方法。

Bean 完成阶段

方法：SmartInitializingSingleton#afterSingletonsInstantiated

在DefaultListableBeanFactory.preInstantiateSingletons完成所有单例、非懒加载的的创建后，会回调这些Bean中所有实现了SmartInitializingSingleton接口的方法afterSingletonsInstantiated。通过它的方法调用能保证所有的单例Bean已经创建，在很多时候非常有用。

Bean 销毁阶段

方法：DisposableBeanAdapter#destroy

有很多入口，主要由ApplicationContext容器关闭时通过DefaultListableBeanFactory#destroySingletons调用。

销毁流程：

  1. 销毁前阶段

    方法：DestructionAwareBeanPostProcessor#postProcessBeforeDestruction

    主要就是CommonAnnotationBeanPostProcessor的@PreDestroy处理逻辑。

  2. DisposableBean销毁

    方法：DisposableBean#destroy

  3. 自定义销毁方法

    调用注册时的销毁方法（@Bean配置、XML配置等）

问题记录

InstantiationAwareBeanPostProcessor顺序问题

问题复现：在ApplicationContext中，实现InstantiationAwareBeanPostProcessor#postProcessProperties（和postProcessPropertyValues）方法且返回null，若没有同时实现MergedBeanDefinitionPostProcessor，会导致@Resource、@Autowired、@Value、@Inject失效，就算实现了Order、PriorityOrdered接口，指定最低优先级也没用。按道理Spring会根据Order顺序执行，可是当这种情况下会发现自定义的InstantiationAwareBeanPostProcessor会在CommonAnnotationBeanPostProcessor和AutowiredAnnotationBeanPostProcessor之前。

原因分析：ApplicationContext#registerBeanPostProcessors是通过PostProcessorRegistrationDelegate.registerBeanPostProcessors注册BeanPostProcessor的，一开始会按照PriorityOrdered、Order接口进行顺序注册，但在最后会把内部的BeanPostProcessor重新注册一遍，而判断的方法就是是否MergedBeanDefinitionPostProcessor，而BeanPostProcessor注册时是先把原有的删除在添加到队列尾部。

public static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
......

   // 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);
         //内部BeanPostProcessor判断
         if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
         }
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   // First, register the BeanPostProcessors that implement PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // Next, register the BeanPostProcessors that implement Ordered.
   List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   for (String ppName : orderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      orderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   // Now, register all regular BeanPostProcessors.
   List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
   for (String ppName : nonOrderedPostProcessorNames) {
      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.
   //会把内部的BeanPostProcessors重新注册
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);
......
}

To be continued...

References

原创不易，禁止未授权的转载。如果我的文章对您有帮助，就请点赞/收藏/关注鼓励支持一下吧

你可能感兴趣的:(Spring 容器对于 Bean 生命周期处理)

  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • 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<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • 2021-08-26 影幽
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 情殇——（5）压抑的小木匠放纵了自己。 石疯聊情感故事
    木讷的小木匠，其实只是不苟言笑。其实内心深处也是挣扎着，由于性格内敛，不喜形于色，给人的感觉非常的木讷。其实小木匠情商智商都不低。他为人扎实，非常的务实。他的爱是既深沉又宽容。可是是一个男人，都会对妻子出轨的事儿，不会忘怀！只是压抑在心底，为了某种考量或许是真爱。小木匠对于丽影和别人私奔又重回家庭，表面上并没有，天翻地覆，暴风骤雨，其内心深处也是经历了，痛苦的挣扎。。。再一次酒后，他和一个离家多年
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • LLM 词汇表 落难Coder LLMsNLP大语言模型大模型llama人工智能
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • 蘩漪：新女性？利己主义者 赮_红雨
    蘩漪是曹禺《雷雨》笔下的女性形象。对于她的喜爱，曹禺在之前的访谈中，就已经表达得很清楚了，蘩漪是他所倾心的女子的“代替者”。在这个女性身上有着曹禺最精心的描写，但同时她的身上又存在着一些时代的问题。图片发自App首先，繁漪是追求自由和幸福的新女性形象。她是精神悲剧的核心人物，她对周朴园的反抗，具有典型意义。她是位资产阶级家庭出身的小姐，受过五四新思潮的影响，她任性、傲慢，追求人格独立、个性自由和爱
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchaineasyui前端python
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
  • 使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twittereasyui前端python
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
  • 利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http网络协议网络python
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
  • Day17笔记-高阶函数 ~在杰难逃~ Python笔记python开发语言pycharm数据分析
    高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • MYSQL面试系列-04 king01299 面试mysql面试
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
  • Kafka 消息丢失如何处理？ 架构文摘JGWZ 学习
    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
  • webpack图片等资源的处理 dmengmeng
    需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
  • 走向以教育叙事为载体的教育叙事研究 666小飞鱼
    今天我读了吴松超老师的《给教师的68条建写作建议》中的第23条《如何通过教育叙事走向研究》，吴老师在文中与我们分享了一个德育案例，这是一个反面的案例，意在告知我们在处理问题时，不能就考虑的点太窄，思考要全面。走向教育叙事研究，教师要有敏锐的“感知力”，这个感知力来自于背后专业知识的支撑，思维能力以及广阔的视野和见识等。所以对于同一件事处理方法不同，这个就是教师背后“敏锐力”的不同造成的，也就是说是
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 穷人做什么生意最赚钱？10个适合穷人赚钱的路子？ 氧惠爱高省
    不管在什么地方，一般都是穷人占大量数，而富人只有少数，但是它们却掌握着大量的财富。对于穷人来说，想要买车、买房等奢侈品就难如登天，因为他们只能通过打工来赚取几千元的月薪。➤推荐网购返利app“氧惠”，一个领隐藏优惠券+现金返利的平台。氧惠只提供领券返利链接，下单全程都在淘宝、京东、拼多多等原平台，更支持抖音、快手电商、外卖红包返利等。（应用市场搜“氧惠”下载，邀请码:521521，全网优惠上氧惠！
  • ios内付费 374016526 ios内付费
    近年来写了很多IOS的程序，内付费也用到不少，使用IOS的内付费实现起来比较麻烦，这里我写了一个简单的内付费包，希望对大家有帮助。   具体使用如下: 这里的sender其实就是调用者，这里主要是为了回调使用。 [KuroStoreApi kuroStoreProductId:@"产品ID" storeSender:self storeFinishCallBa
  • 20 款优秀的 Linux 终端仿真器 brotherlamp linuxlinux视频linux资料linux自学linux教程
      终端仿真器是一款用其它显示架构重现可视终端的计算机程序。换句话说就是终端仿真器能使哑终端看似像一台连接上了服务器的客户机。终端仿真器允许最终用户用文本用户界面和命令行来访问控制台和应用程序。（LCTT 译注：终端仿真器原意指对大型机-哑终端方式的模拟，不过在当今的 Linux 环境中，常指通过远程或本地方式连接的伪终端，俗称“终端”。） 你能从开源世界中找到大量的终端仿真器，它们
  • Solr Deep Paging(solr 深分页) eksliang solr深分页solr分页性能问题
    转载请出自出处：http://eksliang.iteye.com/blog/2148370 作者：eksliang(ickes) blg:http://eksliang.iteye.com/ 概述 长期以来，我们一直有一个深分页问题。如果直接跳到很靠后的页数，查询速度会比较慢。这是因为Solr的需要为查询从开始遍历所有数据。直到Solr的4.7这个问题一直没有一个很好的解决方案。直到solr
  • 数据库面试题 18289753290 面试题 数据库
    1.union ,union all 网络搜索出的最佳答案： union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复。 Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序； Union All：对两个结果集进行并集操作，包括重复行，不进行排序； 2.索引有哪些分类？作用是
  • Android TV屏幕适配 酷的飞上天空 android
    先说下现在市面上TV分辨率的大概情况 两种分辨率为主 1.720标清，分辨率为1280x720. 屏幕尺寸以32寸为主，部分电视为42寸 2.1080p全高清，分辨率为1920x1080 屏幕尺寸以42寸为主，此分辨率电视屏幕从32寸到50寸都有   适配遇到问题，已1080p尺寸为例： 分辨率固定不变，屏幕尺寸变化较大。 如：效果图尺寸为1920x1080，如果使用d
  • Timer定时器与ActionListener联合应用 永夜-极光 java
    功能:在控制台每秒输出一次   代码: package Main; import javax.swing.Timer; import java.awt.event.*; public class T { private static int count = 0; public static void main(String[] args){
  • Ubuntu14.04系统Tab键不能自动补全问题解决 随便小屋 Ubuntu 14.04
    Unbuntu 14.4安装之后就在终端中使用Tab键不能自动补全，解决办法如下：   1、利用vi编辑器打开/etc/bash.bashrc文件（需要root权限） sudo vi /etc/bash.bashrc  接下来会提示输入密码 2、找到文件中的下列代码 #enable bash completion in interactive shells #if
  • 学会人际关系三招 轻松走职场 aijuans 职场
    要想成功，仅有专业能力是不够的，处理好与老板、同事及下属的人际关系也是门大学问。如何才能在职场如鱼得水、游刃有余呢？在此，教您简单实用的三个窍门。 　　第一，多汇报 最近，管理学又提出了一个新名词“追随力”。它告诉我们，做下属最关键的就是要多请示汇报，让上司随时了解你的工作进度，有了新想法也要及时建议。不知不觉，你就有了“追随力”，上司会越来越了解和信任你。 　　第二，勤沟通 团队的力
  • 《O2O：移动互联网时代的商业革命》读书笔记 aoyouzi 读书笔记
    移动互联网的未来：碎片化内容+碎片化渠道=各式精准、互动的新型社会化营销。   O2O：Online to OffLine 线上线下活动 O2O就是在移动互联网时代，生活消费领域通过线上和线下互动的一种新型商业模式。   手机二维码本质：O2O商务行为从线下现实世界到线上虚拟世界的入口。   线上虚拟世界创造的本意是打破信息鸿沟，让不同地域、不同需求的人
  • js实现图片随鼠标滚动的效果 百合不是茶 JavaScript滚动属性的获取图片滚动属性获取页面加载
    1,获取样式属性值 top 与顶部的距离 left 与左边的距离 right 与右边的距离 bottom 与下边的距离 zIndex 层叠层次     例子:获取左边的宽度,当css写在body标签中时 <div id="adver" style="position:absolute;top:50px;left:1000p
  • ajax同步异步参数async bijian1013 jqueryAjaxasync
            开发项目开发过程中，需要将ajax的返回值赋到全局变量中，然后在该页面其他地方引用，因为ajax异步的原因一直无法成功，需将async:false，使其变成同步的。         格式： $.ajax({ type: 'POST', ur
  • Webx3框架（1） Bill_chen eclipsespringmaven框架ibatis
    Webx是淘宝开发的一套Web开发框架，Webx3是其第三个升级版本；采用Eclipse的开发环境，现在支持java开发； 采用turbine原型的MVC框架，扩展了Spring容器，利用Maven进行项目的构建管理，灵活的ibatis持久层支持，总的来说，还是一套很不错的Web框架。 Webx3遵循turbine风格，velocity的模板被分为layout/screen/control三部
  • 【MongoDB学习笔记五】MongoDB概述 bit1129 mongodb
    MongoDB是面向文档的NoSQL数据库，尽量业界还对MongoDB存在一些质疑的声音，比如性能尤其是查询性能、数据一致性的支持没有想象的那么好，但是MongoDB用户群确实已经够多。MongoDB的亮点不在于它的性能，而是它处理非结构化数据的能力以及内置对分布式的支持(复制、分片达到的高可用、高可伸缩)，同时它提供的近似于SQL的查询能力，也是在做NoSQL技术选型时，考虑的一个重要因素。Mo
  • spring/hibernate/struts2常见异常总结 白糖_ Hibernate
    Spring ①ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException 缺少aspectjweaver.jar，该jar包常用于spring aop中   ②java.lang.ClassNotFoundException: org.sprin
  • jquery easyui表单重置(reset)扩展思路 bozch formjquery easyuireset
    在jquery easyui表单中 尚未提供表单重置的功能，这就需要自己对其进行扩展。 扩展的时候要考虑的控件有： combo,combobox,combogrid,combotree,datebox,datetimebox 需要对其添加reset方法，reset方法就是把初始化的值赋值给当前的组件，这就需要在组件的初始化时将值保存下来。 在所有的reset方法添加完毕之后，就需要对fo
  • 编程之美-烙饼排序 bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; /* *《编程之美》的思路是：搜索+剪枝。有点像是写下棋程序：当前情况下，把所有可能的下一步都做一遍；在这每一遍操作里面，计算出如果按这一步走的话，能不能赢（得出最优结果）。 *《编程之美》上代码有很多错误，且每个变量的含义令人费解。因此我按我的理解写了以下代码： */
  • Struts1.X 源码分析之ActionForm赋值原理 chenbowen00 struts
    struts1在处理请求参数之前，首先会根据配置文件action节点的name属性创建对应的ActionForm。如果配置了name属性，却找不到对应的ActionForm类也不会报错，只是不会处理本次请求的请求参数。 如果找到了对应的ActionForm类，则先判断是否已经存在ActionForm的实例，如果不存在则创建实例，并将其存放在对应的作用域中。作用域由配置文件action节点的s
  • [空天防御与经济]在获得充足的外部资源之前,太空投资需有限度 comsci 资源
          这里有一个常识性的问题:       地球的资源,人类的资金是有限的,而太空是无限的.....       就算全人类联合起来,要在太空中修建大型空间站,也不一定能够成功,因为资源和资金,技术有客观的限制.... &
  • ORACLE临时表—ON COMMIT PRESERVE ROWS daizj oracle临时表
    ORACLE临时表 转 临时表：像普通表一样，有结构，但是对数据的管理上不一样，临时表存储事务或会话的中间结果集，临时表中保存的数据只对当前 会话可见，所有会话都看不到其他会话的数据，即使其他会话提交了，也看不到。临时表不存在并发行为，因为他们对于当前会话都是独立的。 创建临时表时，ORACLE只创建了表的结构（在数据字典中定义），并没有初始化内存空间，当某一会话使用临时表时，ORALCE会
  • 基于Nginx XSendfile+SpringMVC进行文件下载 denger 应用服务器Webnginx网络应用lighttpd
        在平常我们实现文件下载通常是通过普通 read-write方式，如下代码所示。 @RequestMapping("/courseware/{id}") public void download(@PathVariable("id") String courseID, HttpServletResp
  • scanf接受char类型的字符 dcj3sjt126com c
    /* 2013年3月11日22:35:54 目的：学习char只接受一个字符 */ # include <stdio.h> int main(void) { int i; char ch; scanf("%d", &i); printf("i = %d\n", i); scanf("%
  • 学编程的价值 dcj3sjt126com 编程
    发一个人会编程, 想想以后可以教儿女, 是多么美好的事啊, 不管儿女将来从事什么样的职业, 教一教, 对他思维的开拓大有帮助   像这位朋友学习:   http://blog.sina.com.cn/s/articlelist_2584320772_0_1.html   VirtualGS教程 (By @林泰前): 几十年的老程序员，资深的
  • 二维数组（矩阵）对角线输出 飞天奔月 二维数组
    今天在BBS里面看到这样的面试题目,   1，二维数组（N*N），沿对角线方向，从右上角打印到左下角如N=4： 4*4二维数组  { 1 2 3 4 } { 5 6 7 8 } { 9 10 11 12 } {13 14 15 16 } 打印顺序  4 3 8 2 7 12 1 6 11 16 5 10 15 9 14 13 要
  • Ehcache（08）——可阻塞的Cache——BlockingCache 234390216 并发ehcacheBlockingCache阻塞
    可阻塞的Cache—BlockingCache          在上一节我们提到了显示使用Ehcache锁的问题，其实我们还可以隐式的来使用Ehcache的锁，那就是通过BlockingCache。BlockingCache是Ehcache的一个封装类，可以让我们对Ehcache进行并发操作。其内部的锁机制是使用的net.
  • mysqldiff对数据库间进行差异比较 jackyrong mysqld
      mysqldiff该工具是官方mysql-utilities工具集的一个脚本，可以用来对比不同数据库之间的表结构，或者同个数据库间的表结构    如果在windows下，直接下载mysql-utilities安装就可以了，然后运行后，会跑到命令行下： 1） 基本用法    mysqldiff --server1=admin:12345
  • spring data jpa 方法中可用的关键字 lawrence.li javaspring
    spring data jpa 支持以方法名进行查询/删除/统计。 查询的关键字为find 删除的关键字为delete/remove (>=1.7.x) 统计的关键字为count (>=1.7.x)   修改需要使用@Modifying注解 @Modifying @Query("update User u set u.firstna
  • Spring的ModelAndView类 nicegege spring
    项目中controller的方法跳转的到ModelAndView类，一直很好奇spring怎么实现的？ /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * yo
  • 搭建 CentOS 6 服务器(13) - rsync、Amanda rensanning centos
    （一）rsync Server端 # yum install rsync # vi /etc/xinetd.d/rsync service rsync { disable = no flags = IPv6 socket_type = stream wait
  • Learn Nodejs 02 toknowme nodejs
    （1）npm是什么 npm is the package manager for node 官方网站：https://www.npmjs.com/ npm上有很多优秀的nodejs包，来解决常见的一些问题，比如用node-mysql，就可以方便通过nodejs链接到mysql，进行数据库的操作 在开发过程往往会需要用到其他的包，使用npm就可以下载这些包来供程序调用 &nb
  • Spring MVC 拦截器 xp9802 spring mvc
    Controller层的拦截器继承于HandlerInterceptorAdapter HandlerInterceptorAdapter.java  1  public   abstract   class  HandlerInterceptorAdapter  implements  HandlerIntercep
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他