网易云Vue3实战商城后台管理系统开发

网易云Vue3实战商城后台管理系统开发

Spring5源码5-Bean生命周期后置处理器

主要说明三种生命周期增强器：

BeanFactoryPostProcessor:BeanFactory 后置处理器

BeanDefinitionRegistryPostProcessor：bean定义注册后置处理器
BeanFactoryPostProcessor
BeanPostProcessor:Bean后置处理器

BeanPostProcessor
MergedBeanDefinitionPostProcessor
SmartInstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor
InitializingBean

DisposableBean (销毁的方案我们暂时不做说明)

1.1 什么是 BeanPostProcessor
BeanPostProcessor 是 Spring提供给我们的一个非常重要的扩展接口，并且Spring内部的很多功能也是通过 BeanPostProcessor 来完成的(目前看到最典型的就是 AnnotationAwareAspectJAutoProxyCreator 的 注入)。

1.2 BeanPostProcessor 的种类
BeanPostProcessor 在Spring 中的子类非常多(idea 显是有46个)，比如

InstantiationAwareBeanPostProcessorAdapter ： 在Spring 的bean加载过程中起了非常重要的作用
AnnotationAwareAspectJAutoProxyCreator ： bean 创建过程中的 属性注入时起作用
AspectJAwareAdvisorAutoProxyCreator ： Aspect 的 AOP 功能实现也全仰仗BeanPostProcessor 的特性。
1.3 创建时机
BeanFactoryPostProcessor：在 Spring 启动时对BeanDefinition 的创建 进行干预处理。

BeanPostProcessor:一是Bean对应的BeanDefinition 的创建。二是Bean 实例的创建。因为在 Spring容器中，Bean的创建并非仅仅通过反射创建就结束了，在创建过程中，需要考虑到Bean针对Spring容器中的一些属性，所以BeanDefinition 中不仅仅包含了 Bean Class 文件信息，还包含了 当前Bean在Spring容器中的一些属性，比如在容器中的作用域、是否懒加载、别名等信息。当Bean 进行实例化创建时需要依赖于对应的BeanDefinition 提供对应的信息。。

而由于 BeanPostProcessor 是参与了 Bean 创建过程。所以其创建一定在普通 Bean 之前。实际上 BeanPostProcessor 的创建时在 Spring 启动时容器刷新的时候。

BeanPostProcessor 的 BeanDefinition 创建时机和普通 Bean没有区别，都是在Spring 启动时的BeanFactoryPostProcessor 中完成(确切的说是 ConfigurationClassPostProcessor 中完成)。

而BeanPostProcessor 的实例创建要优先于普通bean创建，Spring启动过程中会调用AbstractApplicationContext#registerBeanPostProcessors 方法。 在这个方法中，Spring 会从容器中获取到所有BeanPostProcessor 类型的beanName， 通过 beanFactory.getBean 方法获取到对应实例，进行排序后注册到 BeanFactory.beanPostProcessors 属性中.当容器需要执行 BeanPostProcessor 方法时可以直接从 beanPostProcessors 中获取即可。

  1. 案例
    分别定义几个测试类，实现bean的后置处理器：

BeanDefinitionRegistryPostProcessor:

/**

  • BeanFactory的后置处理器 , PriorityOrdered, Ordered
    */

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
public MyBeanDefinitionRegistryPostProcessor(){

  System.out.println("MyBeanDefinitionRegistryPostProcessor");

}

@Override //紧接着执行
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

  System.out.println("MyBeanDefinitionRegistryPostProcessor....postProcessBeanFactory...");

}

@Override //先执行的
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

  System.out.println("MyBeanDefinitionRegistryPostProcessor...postProcessBeanDefinitionRegistry...");
  //增强bean定义信息的注册中心，比如自己注册组件

}
}
复制代码
BeanFactoryPostProcessor:

/**

  • BeanFactory的后置处理器
    */

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

public MyBeanFactoryPostProcessor(){

  System.out.println("MyBeanFactoryPostProcessor...");

}

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

  System.out.println("BeanFactoryPostProcessor....postProcessBeanFactory==>"+beanFactory);

}
}
复制代码
BeanPostProcessor:

/**

  • Bean组件的 PostProcessor；
    */

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

public MyBeanPostProcessor(){

  System.out.println("MyBeanPostProcessor...");

}

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

  System.out.println("MyBeanPostProcessor...postProcessAfterInitialization..."+bean+"==>"+beanName);
  return bean;

}

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

  System.out.println("MyBeanPostProcessor...postProcessBeforeInitialization..."+bean+"==>"+beanName);
  return bean; // new Object();

}
}
复制代码
InstantiationAwareBeanPostProcessor:

@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

public MyInstantiationAwareBeanPostProcessor(){

  System.out.println("MyInstantiationAwareBeanPostProcessor...");

}

//初始化之前进行后置处理，Spring留给我们给这个组件创建对象的回调。
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {

  System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessBeforeInstantiation=>"+beanClass+"--"+beanName);
  //if(class.isAssFrom(Cat.class)){return new Dog()}
  //如果我们自己创建了对象返回。Spring则不会帮我们创建对象，用我们自己创建的对象？ 我们创建的这个对象，Spring会保存单实例？还是每次getBean都调到我们这里创建一个新的？
  return null;

}

// 是否让剩下的后置处理器对bean继续进行处理
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {

  //提前改变一些Spring不管的bean里面的属性
  System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessAfterInstantiation=>"+bean+"--"+beanName);
  return true; //返回false则bean的赋值全部结束

}
//解析自定义注解进行属性值注入；pvs 封装了所有的属性信息。
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)

     throws BeansException { //@GuiguValue();redis
  System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessProperties=>"+bean+"--"+beanName);
  return null;

}

// public PropertyValues postProcessPropertyValues(
// PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
// System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessProperties");
// return pvs;
// }
}
复制代码
MergedBeanDefinitionPostProcessor:

@Component
public class MyMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

public MyMergedBeanDefinitionPostProcessor(){

  System.out.println("MyMergedBeanDefinitionPostProcessor...");

}

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

  System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessBeforeInitialization...=>"+bean+"--"+beanName);
  return bean; //null

}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

  System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessAfterInitialization..=>"+bean+"--"+beanName);
  return null;

}

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {

  System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessMergedBeanDefinition..=>"+beanName+"--"+beanType+"---"+beanDefinition);

}

@Override
public void resetBeanDefinition(String beanName) {

  System.out.println("MyMergedBeanDefinitionPostProcessor...resetBeanDefinition.."+beanName);

}
}
复制代码
SmartInstantiationAwareBeanPostProcessor:

@Component //bean进行代理增强期间进行使用
public class MySmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {

public MySmartInstantiationAwareBeanPostProcessor(){

  System.out.println("MySmartInstantiationAwareBeanPostProcessor...");

}

//预测bean的类型，最后一次改变组件类型。
public Class predictBeanType(Class beanClass, String beanName) throws BeansException {

  System.out.println("MySmartInstantiationAwareBeanPostProcessor...predictBeanType=>"+beanClass+"--"+beanName);
  return null;

}

//返回我们要使用的构造器候选列表

public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException {

  System.out.println("MySmartInstantiationAwareBeanPostProcessor...determineCandidateConstructors=>"+beanClass+"--"+beanName);
  //返回一个我们指定的构造器
  return null;

}

 //返回早期的bean引用，定义三级缓存中的bean信息

public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {

  System.out.println("MySmartInstantiationAwareBeanPostProcessor...getEarlyBeanReference=>"+bean+"--"+beanName);

  return bean; //

}

}
复制代码
InitializingBean:

@Component
public class CatInitializingBean implements InitializingBean {

public CatInitializingBean(){

  System.out.println("cat被创建了...");

}

private String name;

@Value("${JAVA_HOME}") //自动赋值功能
public void setName(String name) {

  System.out.println("cat....setName正在赋值调用....");
  this.name = name;

}
//注解怎么定义这个是初始化方法？
public String getName() {

  return name;

}

@Override
public void afterPropertiesSet() throws Exception {

  System.out.println("CatInitializingBean..afterPropertiesSet...");

}

@Autowired
private void init() {

  System.out.println("CatInitializingBean init....");

}

}
复制代码
debug打点：在每个构造器和方法上都打上 断点，主要看看每个方法的执行时机是什么时候？

  1. 源码分析
    入口还是： org.springframework.context.support.AbstractApplicationContext#refresh：

// 容器刷新的十二大步骤
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {

  // 容器启动的状态
  StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

  // Prepare this context for refreshing.
  // 1.准备上下文环境
  prepareRefresh();

  // Tell the subclass to refresh the internal bean factory.
  /** 1、创建BeanFactory对象
  *  2、xml解析
  *  传统标签解析：bean、import等
  *  自定义标签解析 如：
  *  自定义标签解析流程：
  *     a、根据当前解析标签的头信息找到对应的namespaceUri
  *     b、加载spring所以jar中的spring.handlers文件。并建立映射关系
  *     c、根据namespaceUri从映射关系中找到对应的实现了NamespaceHandler接口的类
  *     d、调用类的init方法，init方法是注册了各种自定义标签的解析类
  *     e、根据namespaceUri找到对应的解析类，然后调用paser方法完成标签解析
  * 3、把解析出来的xml标签封装成BeanDefinition对象
  */
  // 2. 工厂创建：BeanFactory 第一次开始创建的时候，有xml解析逻辑
  ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

  // Prepare the bean factory for use in this context.
  // 3. 预准备工厂，给容器中注册了环境信息作为单实例Bean  方便后续自动装配
  // 并且放了一些后置处理器（监听、xxxAware功能）
  prepareBeanFactory(beanFactory);

  try {
     //  Allows post-processing of the bean factory in context subclasses.
     // 留给子类的模板方法，允许子类继续对工厂执行一些处理
     postProcessBeanFactory(beanFactory);

     StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
     // Invoke factory processors registered as beans in the context.
     // 5. 【大核心】工厂增强：执行所有的BeanFactory 后置增强器 利用BeanFactory后置增强器对工厂进行修改或增强
     // 配置类也会在这个解析
     // BeanDefinitionRegistryPostProcessor BeanFactoryPostProcessor 完成对这两个接口的调用
     invokeBeanFactoryPostProcessors(beanFactory);

     // Register bean processors that intercept bean creation.
     // 6. 【核心】注册 所有的Bean的后置处理器
     registerBeanPostProcessors(beanFactory);
     beanPostProcess.end();

     // Initialize message source for this context.
     // 7. 初始化国际化组件
     initMessageSource();

     // Initialize event multicaster for this context.
     // 8. 初始化事件派发 功能
     initApplicationEventMulticaster();

     // Initialize other special beans in specific context subclasses.
     // 9. 留给子类继续增强处理逻辑
     // 这个方法着重理解模板设计模式，因为在springboot中，这个方法是用来做内嵌tomcat启动的
     onRefresh();

     // Check for listener beans and register them.
     // 10. 注册事件监听器，从容器中获取所有的ApplicationListener
     registerListeners();

     // Instantiate all remaining (non-lazy-init) singletons.
     // 11. 【大核心】bean创建：完成BeanFactory 初始化（工厂里面所有的组件都好了）
     /*
      * 这个方法一定要理解要具体看
      * 1、bean实例化过程
      * 2、ioc
      * 3、注解支持
      * 4、BeanPostProcessor的执行
      * 5、Aop的入口
      */
     finishBeanFactoryInitialization(beanFactory);

     // Last step: publish corresponding event.
     // 12. 发布事件
     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();
     contextRefresh.end();
  }

}
}
复制代码
我们主要分析几个方法：

3.1 invokeBeanFactoryPostProcessors(beanFactory)
BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 方法处理都是在这个步骤中。

直接看 PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors()：

public static void invokeBeanFactoryPostProcessors(

  ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

// WARNING: Although it may appear that the body of this method can be easily
// refactored to avoid the use of multiple loops and multiple lists, the use
// of multiple lists and multiple passes over the names of processors is
// intentional. We must ensure that we honor the contracts for PriorityOrdered
// and Ordered processors. Specifically, we must NOT cause processors to be
// instantiated (via getBean() invocations) or registered in the ApplicationContext
// in the wrong order.
//
// Before submitting a pull request (PR) to change this method, please review the
// list of all declined PRs involving changes to PostProcessorRegistrationDelegate
// to ensure that your proposal does not result in a breaking change:
// https://github.com/spring-pro...

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

// 先拿到底层默认有的BeanFactoryPostProcessor，容器会注入ConfigurationClassPostProcessor，配置类的后置处理
if (beanFactory instanceof BeanDefinitionRegistry) {

  BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  List regularPostProcessors = new ArrayList<>();
  List registryProcessors = new ArrayList<>();

  for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
     if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
        BeanDefinitionRegistryPostProcessor registryProcessor =
              (BeanDefinitionRegistryPostProcessor) postProcessor;
        registryProcessor.postProcessBeanDefinitionRegistry(registry);
        registryProcessors.add(registryProcessor);
     }
     else {
        regularPostProcessors.add(postProcessor);
     }
  }

  // Do not initialize FactoryBeans here: We need to leave all regular beans
  // uninitialized to let the bean factory post-processors apply to them!
  // Separate between BeanDefinitionRegistryPostProcessors that implement
  // PriorityOrdered, Ordered, and the rest.
  List currentRegistryProcessors = new ArrayList<>();

  // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
  // 首先，从工厂中获取所有的BeanDefinitionRegistryPostProcessor
  String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  // 获取所有实现PriorityOrdered 接口的的BeanDefinitionRegistryPostProcessor
  for (String ppName : postProcessorNames) {
     if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
        // 从工厂中获取这个组件（getBean组件的创建）并放到这个集合中
        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
        processedBeans.add(ppName);
     }
  }
  // 利用优先级排序
  sortPostProcessors(currentRegistryProcessors, beanFactory);
  registryProcessors.addAll(currentRegistryProcessors);
  // todo 执行这些BeanDefinitionRegistryPostProcessor
  invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
  currentRegistryProcessors.clear();

  // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
  postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  // 接下来，获取所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor
  for (String ppName : postProcessorNames) {
     // 即使实现了Ordered 和PriorityOrdered接口，以PriorityOrdered接口为准
     if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
        processedBeans.add(ppName);
     }
  }
  // 排序
  sortPostProcessors(currentRegistryProcessors, beanFactory);
  registryProcessors.addAll(currentRegistryProcessors);
  invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
  currentRegistryProcessors.clear();

  // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
  // 最后，我们自定义和没有实现 优先级接口的
  boolean reiterate = true;
  while (reiterate) {
     reiterate = false;
     postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
     for (String ppName : postProcessorNames) {
        if (!processedBeans.contains(ppName)) {
           currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
           processedBeans.add(ppName);
           reiterate = true;
        }
     }
     // 排序，根据类名大小写进行排序
     sortPostProcessors(currentRegistryProcessors, beanFactory);
     registryProcessors.addAll(currentRegistryProcessors);
     // todo 执行BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry 方法
     invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
     // 防止重复
     currentRegistryProcessors.clear();
  }

  // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
  // todo 接下来，执行BeanDefinitionRegistryPostProcessor.postProcessBeanFactory 的方法
  invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
  invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

}

else {

  // Invoke factory processors registered with the context instance.
  invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);

}

// todo 上面是执行 BeanDefinitionRegistryPostProcessor，下面是执行 BeanFactoryPostProcessor
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
String[] postProcessorNames =

     beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
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.
// 首先，执行实现PriorityOrdered接口的BeanFactoryPostProcessors
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
// 接下来，执行实现Ordered接口的BeanFactoryPostProcessors
List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {

  orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

// Finally, invoke all other BeanFactoryPostProcessors.
// 最后，执行 没有实现优先级和排序 接口的BeanFactoryPostProcessors
List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {

  nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

}
// todo 执行BeanFactoryPostProcessor.postProcessBeanFactory()方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
复制代码
获取到所有BeanDefinitionRegistryPostProcessor并创建对象，首先，执行PriorityOrdered接口，其次，执行Ordered接口， 最后，执行没有实现优先级 接口，都会执行invokeBeanDefinitionRegistryPostProcessors()方法和invokeBeanFactoryPostProcessors()方法。

3.1.1 invokeBeanDefinitionRegistryPostProcessors()
private static void invokeBeanDefinitionRegistryPostProcessors(

  Collection postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {

for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {

  StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process")
        .tag("postProcessor", postProcessor::toString);
  // todo 核心，配置类的后置处理器在此解析配置类
  postProcessor.postProcessBeanDefinitionRegistry(registry);
  postProcessBeanDefRegistry.end();

}
}
复制代码
在这里会执行BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry方法。

3.1.2 invokeBeanFactoryPostProcessors（）
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

private static void invokeBeanFactoryPostProcessors(

  Collection postProcessors, ConfigurableListableBeanFactory beanFactory) {

for (BeanFactoryPostProcessor postProcessor : postProcessors) {

  StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process")
        .tag("postProcessor", postProcessor::toString);
  // todo
  postProcessor.postProcessBeanFactory(beanFactory);
  postProcessBeanFactory.end();

}
}
复制代码
在这里，入参都是BeanDefinitionRegistryPostProcessor 类型的，所以会执行 BeanDefinitionRegistryPostProcessor.postProcessBeanFactory方法。

3.1.3
接下来，获取到所有BeanFactoryPostProcessor并创建对象，首先，执行PriorityOrdered接口，其次，执行Ordered接口， 最后，执行没有实现优先级 接口，都会执行invokeBeanFactoryPostProcessors()方法。

本次入参是BeanFactoryPostProcessor对象，所以会执行 BeanFactoryPostProcessor.postProcessBeanFactory()方法。

3.1.4 beanFactory.getBeanNamesForType()
spring中如何根据类型获取所有的组件？
DefaultListableBeanFactory#getBeanNamesForType()：

@Override
public String[] getBeanNamesForType(@Nullable Class type, boolean includeNonSingletons, boolean allowEagerInit) {
if (!isConfigurationFrozen() || type == null || !allowEagerInit) {

  // todo
  return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);

}
...
}
复制代码
// 获取某一个组件 在容器中的名字
private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
List result = new ArrayList<>();

// Check all bean definitions.
// 因为Spring没有class-bean的对应信息，只能遍历所有的beanName 拿出他们所有的beanName的定义信息，再看是否指定的类型
// 只有在这里bean实例还未创建的时候，才能使用后置处理器干预 bean的类型
for (String beanName : this.beanDefinitionNames) {

  // Only consider bean as eligible if the bean name is not defined as alias for some other bean.
  if (!isAlias(beanName)) {
     try {
        RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        // Only check bean definition if it is complete.
        if (!mbd.isAbstract() && (allowEagerInit ||
              (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
                    !requiresEagerInitForType(mbd.getFactoryBeanName()))) {
           boolean isFactoryBean = isFactoryBean(beanName, mbd);
           BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
           boolean matchFound = false;
           // containsSingleton(beanName) 是否已经创建单例对象
           boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName));
           boolean isNonLazyDecorated = (dbd != null && !mbd.isLazyInit());
           if (!isFactoryBean) {
              if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) {
                 // 是否类型匹配
                 matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
              }
           }
           else {
              if (includeNonSingletons || isNonLazyDecorated ||
                    (allowFactoryBeanInit && isSingleton(beanName, mbd, dbd))) {
                 // 是否类型匹配
                 matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
              }
              if (!matchFound) {
                 // In case of FactoryBean, try to match FactoryBean instance itself next.
                 beanName = FACTORY_BEAN_PREFIX + beanName;
                 if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) {
                    matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
                 }
              }
           }
           if (matchFound) {
              result.add(beanName);
           }
        }
     }
     catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) {
        if (allowEagerInit) {
           throw ex;
        }
        // Probably a placeholder: let's ignore it for type matching purposes.
        LogMessage message = (ex instanceof CannotLoadBeanClassException ?
              LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) :
              LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName));
        logger.trace(message, ex);
        // Register exception, in case the bean was accidentally unresolvable.
        onSuppressedException(ex);
     }
     catch (NoSuchBeanDefinitionException ex) {
        // Bean definition got removed while we were iterating -> ignore.
     }
  }

}

// Check manually registered singletons too.
for (String beanName : this.manualSingletonNames) {

  try {
     // In case of FactoryBean, match object created by FactoryBean.
     if (isFactoryBean(beanName)) {
        if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
           result.add(beanName);
           // Match found for this bean: do not match FactoryBean itself anymore.
           continue;
        }
        // In case of FactoryBean, try to match FactoryBean itself next.
        beanName = FACTORY_BEAN_PREFIX + beanName;
     }
     // Match raw bean instance (might be raw FactoryBean).
     if (isTypeMatch(beanName, type)) {
        result.add(beanName);
     }
  }
  catch (NoSuchBeanDefinitionException ex) {
     // Shouldn't happen - probably a result of circular reference resolution...
     logger.trace(LogMessage.format(
           "Failed to check manually registered singleton with name '%s'", beanName), ex);
  }

}

return StringUtils.toStringArray(result);
}
复制代码
主要步骤：

拿到所有组件的名字，beanDefinitionNames
遍历每一个组件名字
再去BeanDefinitionMap中找bean的定义信息
从定义信息中获取组件的类型
看这个类型是否匹配
3.2 registerBeanPostProcessors(beanFactory)
注册所有bean的后置处理器， PostProcessorRegistrationDelegate#registerBeanPostProcessors()：

public static void registerBeanPostProcessors(

  ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

// WARNING: Although it may appear that the body of this method can be easily
// refactored to avoid the use of multiple loops and multiple lists, the use
// of multiple lists and multiple passes over the names of processors is
// intentional. We must ensure that we honor the contracts for PriorityOrdered
// and Ordered processors. Specifically, we must NOT cause processors to be
// instantiated (via getBean() invocations) or registered in the ApplicationContext
// in the wrong order.
//
// Before submitting a pull request (PR) to change this method, please review the
// list of all declined PRs involving changes to PostProcessorRegistrationDelegate
// to ensure that your proposal does not result in a breaking change:
// https://github.com/spring-pro...

// 获取到容器中所有的BeanPostProcessor， Bean的后置处理器
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.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

// 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) {

  // 获取所有实现了PriorityOrdered接口
  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 {
     nonOrderedPostProcessorNames.add(ppName);
  }

}

// First, register the BeanPostProcessors that implement PriorityOrdered.
// 首先，注册实现了PriorityOrdered 接口的 BeanPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

// Next, register the BeanPostProcessors that implement Ordered.
// 接下来，注册实现了Ordered 接口的 BeanPostProcessor
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.
// 最后，注册了普通的BeanPostProcessor
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);

// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 重新注册一下 ApplicationListenerDetector 这个后置处理器
// 把 它放到后置处理器的最后一个位置
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
复制代码
这个步骤，将bean的后置处理器BeanPostProcessor、MergedBeanDefinitionPostProcessor、SmartInstantiationAwareBeanPostProcessor、InstantiationAwareBeanPostProcessor都注册并初始话实例。

3.3 registerListeners()
这个核心是注册监听器事件，这个我们后面再说，今天主要说明SmartInstantiationAwareBeanPostProcessor.predictBeanType()干预bean的类型。

/**

  • Add beans that implement ApplicationListener as listeners.
  • Doesn't affect other listeners, which can be added without being beans.
  • 多播器 和监听器 是观察者模式，里面包含了所有的监听器
    */

protected void registerListeners() {
...
// 获取ApplicationListener 在ioc容器中注册的bean的名字
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {

  // 获取所有的监听器，并保存他们的名字在
  getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

}
...
}
复制代码
也会执行getBeanNamesForType()方法，前面我们简单分析过，我们直接来到：AbstractAutowireCapableBeanFactory#predictBeanType方法：

@Override
@Nullable
protected Class predictBeanType(String beanName, RootBeanDefinition mbd, Class... typesToMatch) {
Class targetType = determineTargetType(beanName, mbd, typesToMatch);
// Apply SmartInstantiationAwareBeanPostProcessors to predict the
// eventual type after a before-instantiation shortcut.
if (targetType != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {

  boolean matchingOnlyFactoryBean = typesToMatch.length == 1 && typesToMatch[0] == FactoryBean.class;
  // todo 执行SmartInstantiationAwareBeanPostProcessor.predictBeanType方法
  for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
     Class predicted = bp.predictBeanType(targetType, beanName);
     if (predicted != null &&
           (!matchingOnlyFactoryBean || FactoryBean.class.isAssignableFrom(predicted))) {
        return predicted;
     }
  }

}
return targetType;
}
复制代码
在3.1节中 执行Bean工厂的后置处理器的时候，hasInstantiationAwareBeanPostProcessors()为false,所以进入不了这个方法，原因是因为在invokeBeanFactoryPostProcessors()方法的时候，BeanPostProcessor在容器中还没有，所以不会执行。

但是，registerListeners()在registerBeanPostProcessors()方法之后，所以可以执行这个方法，也就是SmartInstantiationAwareBeanPostProcessor.predictBeanType()干预bean的组件类型。

3.4 finishBeanFactoryInitialization()
完成BeanFactory 初始化（工厂里面所有的组件都好了）。 beanFactory.preInstantiateSingletons()-> getBean(beanName)->doGetBean->createBean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

  throws BeanCreationException {

...
try {

  // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  // todo 提前给我们一个机会，去返回组件的代理对象
  Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  if (bean != null) {
     return bean;
  }

}
...
try {

  // todo 创建对象
  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  if (logger.isTraceEnabled()) {
     logger.trace("Finished creating instance of bean '" + beanName + "'");
  }
  return beanInstance;

}
...
}
复制代码
3.4.1 resolveBeforeInstantiation(beanName, mbdToUse)
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) {
        // todo InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()方法
        bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
        if (bean != null) {
           bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
        }
     }
  }
  mbd.beforeInstantiationResolved = (bean != null);

}
return bean;
}
复制代码
protected Object applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {

  // todo  执行
  Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
  if (result != null) {
     return result;
  }

}
return null;
}
复制代码
在这里执行 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()方法。如果该方法返回true,则直接执行applyBeanPostProcessorsAfterInitialization()方法：

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)

  throws BeansException {

Object result = existingBean;
// todo 执行所有BeanPostProcessor.postProcessAfterInitialization()方法
// 所有的BeanPostProcessor类型
for (BeanPostProcessor processor : getBeanPostProcessors()) {

  Object current = processor.postProcessAfterInitialization(result, beanName);
  if (current == null) {
     return result;
  }
  result = current;

}
return result;
}
复制代码
在这里执行所有BeanPostProcessor.postProcessAfterInitialization()方法。

接下来，我们看一下doCreateBean方法。

3.4.2 doCreaeBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

  throws BeanCreationException {

// Instantiate the bean.
BeanWrapper instanceWrapper = null;
// 是否单例
if (mbd.isSingleton()) {

  instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

}
if (instanceWrapper == null) {

  // todo 创建Bean实例 ，默认使用无参构造器创建的对象，组件的实例就创建了
  instanceWrapper = createBeanInstance(beanName, mbd, args);

}
Object bean = instanceWrapper.getWrappedInstance();
Class beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {

  mbd.resolvedTargetType = beanType;

}

// Allow post-processors to modify the merged bean definition.
// MergedBeanDefinitionPostProcessor 后置处理器再来修改下BeanDefinition 信息
synchronized (mbd.postProcessingLock) {

  if (!mbd.postProcessed) {
     try {
        // todo 执行MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()方法
        applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
     }
     catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
              "Post-processing of merged bean definition failed", ex);
     }
     mbd.postProcessed = true;
  }

}

// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 提前暴露 单实例bean 专门来解决循坏引用的问题
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&

     isSingletonCurrentlyInCreation(beanName));

if (earlySingletonExposure) {

  if (logger.isTraceEnabled()) {
     logger.trace("Eagerly caching bean '" + beanName +
           "' to allow for resolving potential circular references");
  }
  // 添加
  // 三级缓存中Bean也会被后置处理来增强
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

}

// Initialize the bean instance.
Object exposedObject = bean;
try {

  // todo 对象中的每个属性赋值
  populateBean(beanName, mbd, instanceWrapper);
  // todo 初始化Bean
  exposedObject = initializeBean(beanName, exposedObject, mbd);

}
...

return exposedObject;
}
复制代码
3.4.2.1 createBeanInstance(beanName, mbd, args)
创建bean实例，默认使用无参构造器。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
// 创建bean的类型
Class beanClass = resolveBeanClass(mbd, beanName);
...

// Candidate constructors for autowiring?
// todo 候选的构造器 SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors()
// 后置处理器有机会在这个决定当前bean使用哪个构造器
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);
}
复制代码
在determineConstructorsFromBeanPostProcessors方法中可以决定使用构造器。

protected Constructor[] determineConstructorsFromBeanPostProcessors(@Nullable Class beanClass, String beanName)

  throws BeansException {

if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {

  for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
     // todo 执行SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors()方法
     Constructor[] ctors = bp.determineCandidateConstructors(beanClass, beanName);
     if (ctors != null) {
        return ctors;
     }
  }

}
return null;
}
复制代码
在这里执行SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors()方法。

3.4.2.2 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class beanType, String beanName) {
// todo 执行MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()方法
for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {

  processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);

}
}
复制代码
在这里执行MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()方法。

3.4.2.3 populateBean(beanName, mbd, instanceWrapper)
对每个属性进行赋值操作。

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
...

// 属性赋值之前，后置处理器可以提前准备些东西
// @AutoWired 赋值也在这里 AutowiredAnnotationBeanPostProcessor(直接返回true 没有其他的处理)，可以中断初始化行为
//
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {

  for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
     // todo 执行InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法
     if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
        return;
     }
  }

} // 以上的后置处理器可以中断下面的初始化行为

...

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

PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {

  if (pvs == null) {
     // xml中property标签指定的
     pvs = mbd.getPropertyValues();
  }
  // 注解版的属性赋值 后置处理器处理属性（真正的自动装配）
  for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
     // todo 执行InstantiationAwareBeanPostProcessor.postProcessProperties() 方法
     PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
     if (pvsToUse == null) {
        if (filteredPds == null) {
           filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
        if (pvsToUse == null) {
           return;
        }
     }
     pvs = pvsToUse; //  封装了当前bean的所有属性名和值，可以由后置处理器处理得到
  }

}
...

if (pvs != null) { // 把以前处理好的PropertyValues 给bean里面设置一下，主要是上面步骤没有给bean里面设置的属性

  // xml版 的所有配置会来到这里 给属性赋值
  applyPropertyValues(beanName, mbd, bw, pvs);

}
}
复制代码
这里，会执行2个后置处理器的方法：

执行InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法
执行InstantiationAwareBeanPostProcessor.postProcessProperties() 方法
3.4.2.4 initializeBean(beanName, exposedObject, mbd)
对bean进行初始化操作。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {

  AccessController.doPrivileged((PrivilegedAction) () -> {
     invokeAwareMethods(beanName, bean);
     return null;
  }, getAccessControlContext()); 
 
}
 else {
 
 
  // 组件有Aware接口，先Aware; BeanNameAware BeanClassLoaderAware BeanFactoryAware
  invokeAwareMethods(beanName, bean);
 
 
}
 
 
Object wrappedBean = bean;
 if (mbd == null || !mbd.isSynthetic()) {
 
 
  // todo 执行后置处理器的 BeforeInitialization，可以改变之前创建的bean实例
  wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 
 
}
 
 
try {
 
 
  // todo 执行初始化方法 实现InitializingBean 的接口
  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()) {
 
 
  // todo 执行后置处理器的  postProcessAfterInitialization
  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 
 
}
 
 
return wrappedBean;
}
复制代码
在这里，执行三个后置处理器的方法：
 
 
执行所有BeanPostProcessor.postProcessBeforeInitialization()方法
实现InitializingBean 的接口，执行初始化方法实现InitializingBean.afterPropertiesSet() 方法
执行所有BeanPostProcessor.postProcessAfterInitialization()方法
到此，bean生命周期的所有后置处理器方法的执行时机已经全部展示出来
 
 
download：网易云Vue3实战商城后台管理系统开发
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(vue3)

        

            

                
    
                    
  • vue3中el-table中点击图片放大时，被表格覆盖
                        叫我小鹏呀
vue.jsjavascript前端
                        
    问题：vue3中el-table中点击图片放大时，被表格覆盖。解决方法：el-image添加preview-teleported
    
                    
    • 
                    
  • vue render 函数详解 (配参数详解)
                        你的眼睛會笑
vue2vue.jsjavascript前端
                        
    vuerender函数详解(配参数详解)在Vue3中，`render`函数被用来代替Vue2中的模板语法。它接收一个h函数（或者是`createElement`函数的别名），并且返回一个虚拟DOM。render函数的语法结构如下：render(h){returnh('div',{class:'container'},'Hello,World!')}在上面的示例中，我们使用h函数创建了一个div元素
    
                    
    • 
                    
  • VUE3 + xterm + nestjs实现web远程终端 或 连接开启SSH登录的路由器和交换机。
                        焚木灵
node.jsvue
                        
    可远程连接系统终端或开启SSH登录的路由器和交换机。相关资料：xtermjs/xterm.js:Aterminalfortheweb(github.com)后端实现(NestJS)：1、安装依赖：npminstallnode-ssh@nestjs/websockets@nestjs/platform-socket.io2、我们将创建一个名为RemoteControlModule的NestJS模块，
    
                    
    • 
                    
  • 【vite 自动配置路由】
                        CODER-V
前端javascriptvue.js前端软件构建
                        
    手动配置路由，是一个没有技术含量又浪费时间的工作。本文将介绍vite构建的vue3项目如何编写一个自动配置路由的脚本。约定大于配置要想使用脚本完成路由的自动配置，我们就需要遵循以下目录规则：每一个页面对应一个包，当前包下的主页面命名为index.vue；每个包里必须配置一个page.js；在每一个page.js里边配置，额外的路由信息，比如：exportdefault{title:'商品',men
    
                    
    • 
                    
  • Vue3 vant组件库自动导入
                        不叫虎子
Vuevue.js前端javascript前端框架typescript
                        
    实现：完整使用vant组件库文档安装：#Vue3项目，安装最新版Vantnpmivant#通过yarn安装yarnaddvant#通过pnpm安装pnpmaddvant【一】按需引入：https://vant-contrib.gitee.io/vant/#/zh-CN/quickstart#fang-fa-er.-an-xu-yin-ru-zu-jian-yang-shi【二】批量引入在基于vit
    
                    
    • 
                    
  • 锋哥写一套前后端分离Python权限系统 基于Django5+DRF+Vue3.2+Element Plus+Jwt 视频教程 ，帅呆了~~
                        java1234_小锋
Python权限系统django权限系统pythonweb权限系统djangoDRFVUE权限python
                        
    大家好，我是java1234_小锋老师，最近写了一套【前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt】视频教程，持续更新中，计划月底更新完，感谢支持。视频在线地址：打造前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt视频教程（火爆连载更新中..）_哔哩哔哩_bilibili项目介绍本课程采
    
                    
    • 
                    
  • vue3+ts+supermap icilent3d for cesium功能集合
                        用你的胜利博我一笑吧
arcgis
                        
    会把各项功能链接放在这1.vue3配置supermapicilent3dforcesiumvue3中使用supermapicilent3dforcesium_npm引入supermapgis-CSDN博客2.功能2.1加载天地图，加载地形，夸大地形supermapicilent3dforcesium加载地形并夸大地形-CSDN博客2.2加载雨雪天气，并添加白色的材质2.3调整图层高度，透明度等信息
    
                    
    • 
                    
  • vue3 + vite + js 配置Eslint + prettier
                        菜鸡的崛起
vuejavascriptvue
                        
    第一步安装ESlintnpmieslint@latest-D或pnpmaddeslint@latest-D/pnpminstalleslint@latest-D或yarnaddeslint@latest-D第二步初始化Eslintnpxeslint--init执行npxeslint--init控制台会出现以下步骤1）你想如何使用ESLint（选择最后一个）Youcanalsorunthiscomm
    
                    
    • 
                    
  • Vue3项目开发——新闻发布管理系统（六）
                        bjzhang75
Vue知识学习及项目开发实践Vue3项目开发新闻发布管理系统
                        
    文章目录八、首页设计开发1、页面设计2、登录访问拦截实现3、用户基本信息显示①封装用户基本信息获取接口②用户基本信息存储③用户基本信息调用④用户基本信息动态渲染4、退出功能实现①注册点击事件②添加退出功能③数据清理5、代码下载八、首页设计开发登录成功后，系统就进入了首页。接下来，也就进行首页的开发了。1、页面设计系统页面主要分为三部分，左侧为系统的菜单栏，右侧上部为系统的头部，下部为系统的主体区域
    
                    
    • 
                    
  • vue3 - element-plus表格组件el-table实现鼠标拖曳排序功能，vue3 Table表格拖拽排序，表格每行使用鼠标拖动进行排序功能，表格拖拽排序实现（详细示例代码，一键复制开箱即用
                        街尾杂货店&
前端组件与功能(开箱即用)elementPlusvue3el-tableTable表格拖动时动态排序表格组件鼠标拖拽排序示例代码树型tree复杂表格拖曳排序element表格行可拖动排序
                        
    效果图在vue3+elementPlus网站开发中，详细完成el-table表格的鼠标拖拽/拖曳/拖动排序，vue3使用elementplus表格组件进行表格每行的拖动换位置排序功能（支持一键开启和关闭鼠标是否可拖动排序，代码易改造灵活），稍加改造可支持【树形复杂表格的排序】！详细示例源代码，复制运行稍微改下就能用了。准备开始首先，
    
                    
    • 
                    
  • 【Vue3源码实现】Ref isRef unRef proxyRefs实现
                        ZhaiMou
vue.jsjavascript前端数据结构前端框架开发语言
                        
    前言在上篇文章中我们了解了响应式原理，并在最后实现了reactive。上文链接Vue3响应式原理实现与track和trigger依赖收集和触发依赖在我们的日常业务中，我们有可能需要将一个基础数据类型的值也转换成响应式的，而reactive只能代理对象，我们需要对基础数据类型的值也进行读写操作的拦截，但Proxy无法实现对基础数据类型值读写操作的拦截。所以Vue设计了Ref,以及相关api本篇文章实
    
                    
    • 
                    
  • vue3 响应性API
                        weixin_44747590
vue3vuejs
                        
    toRef可以用来为源响应式对象上的property性创建一个ref。然后可以将ref传递出去，从而保持对其源property的响应式连接。本质类似指针引用。举例：conststate=reactive({foo:1,bar:2})constfooRef=toRef(state,'foo')fooRef.value++console.log(state.foo)//2state.foo++cons
    
                    
    • 
                    
  • 手撸vue3核心源码——响应式原理(isRef和unRef)
                        前端不是渣男
前端vue.js
                        
    今天来实现一下ref的功能函数，isRef与unRefisRefisRef和isReactive一样，都是用于检测数据类型，isRef是检测是不是一个ref对象,跟isReactive函数实现起来一样,我们先来写一个单元测试这里要实现的功能是，检测ref对象肯定就通过返回true，检测普通类型数据以及reactive对象都是falseit("itshouldreturnaboolean",()=>
    
                    
    • 
                    
  • vue3 | isRef、unref、toRef、toRefs
                        杨贵妃会飞飞飞
Vuevue.js前端
                        
    isRef检查某个值是否是ref。是返回true，否则返回false。constnum=ref(10)constnum1=20constnum2=reactive({data:30})console.log(isRef(num))//trueconsole.log(isRef(num1))//falseconsole.log(isRef(num2))//falseunref()如果参数是ref，则
    
                    
    • 
                    
  • vue学习笔记——关于对Vue3 ref(), toRef(), toRefs(), unref(), isRef(), reactive()方法的理解。
                        chen_sir_sh
vue学习笔记javascript前端vue
                        
    VUE3出现了很多新的API，下面是自己的一些理解进行的总结。欢迎大家一起交流补充。ref()使用ref创建一个数据类型，ref有value这个属性constname1={age:"14",name:"bob1"};constname2=ref({name:"bob2"});//使用ref创建一个数据类型相对于reactive，ref有value属性name2.value="bob3"consol
    
                    
    • 
                    
  • [深入vue3之refs] ref、unref、toRef、toRefs、isRef、customRef、shallowRef、triggerRef等使用与讲解
                        oumae-kumiko
vue前端vue.js前端javascript
                        
    本章涉及的compositionapi：ref、unref、toRef、toRefs、isRef、customRef、shallowRef、triggerRefrefsapi中的重点为：ref、toRefs、shallowRef、customRef，其次是isRef等。ref接受一个内部值并返回一个响应式且可变的ref对象。ref对象仅有一个`.value`property，指向该内部值。如果将对
    
                    
    • 
                    
  • vue3-响应式API(工具函数)-unRef
                        hx_1199
vue3前端javascriptvue.js
                        
    unRef作用：如果参数是ref，则返回内部值，否则返回参数本身。理解：val=isRef(val)?val.value:val应用：sortField=unref(tableRef)?.getSortFields()
    
                    
    • 
                    
  • vue3 响应式API customRef()
                        fishmemory7sec
vue3javascriptvue.js前端
                        
    使用ref()定义响应式数据：{{inputValue}}import{ref}from'vue';constinputValue=ref('hello')使用Vue提供的默认ref()定义响应式数据，当数据发生变化时，Vue的响应式系统会自动检测到变化，并立即更新相关的页面部分。现在，实现如下图所示的需求：当在输入框输入123时，输入结束1秒后，页面才更新。将输入框与inputValue进行双向
    
                    
    • 
                    
  • vue3 内置组件＜Teleport＞
                        fishmemory7sec
vue3vue.js前端
                        
    官方文档：Teleport内置组件将一个组件的模板内容渲染到指定的DOM节点位置，而不是在组件自身的挂载点。组件的参数说明：to：必填项。指定目标容器。可以是选择器或实际元素。类型：string|HTMLElement作用：指定要将内容传送（teleport）到的目标位置。可以是一个CSS选择器字符串，用于选择一个现存的DOM元素，也可以是一个实际的DOM元素对象引用。示例：disabled：可选
    
                    
    • 
                    
  • qiankun 结合 vue3， 小白快速上手体验
                        陈y_d
vue.js前端javascript
                        
    一、主应用改造首先需要维护一份微应用列表，里面包含了微应用的名称、入口和生效规则，若需要给子应用传递内容，可以在props传入对应的内容//app.jsconstapps=[{name:'micro-vue-app3',entry:'//localhost:3013',container:'#micro-vue-app3',activeRule:'/micro-vue3-app3',props:{
    
                    
    • 
                    
  • 开源项目低代码表单FormCreate从Vue2到Vue3升级指南
                        低代码研究员
FormCreate开源低代码FormCreate低代码表单低代码设计器动态表单
                        
    开源项目低代码表单FormCreatev3版本基于Vue3.0构建，尽管功能与v2版本大致相同，但有一些重要的变更和不兼容项需要注意。源码地址:Github|GiteeFormCreatev3对比v2版本在一些功能和配置项上做了调整，以更好地支持Vue3的新特性。以下是v2到v3升级过程中需要关注的变化和调整。移除配置项在v3版本中，以下配置项已被移除，因为它们在Vue3中不再适用：attrs：在
    
                    
    • 
                    
  • 从零开始一步一步搭建 Vue3 + Webpack5 项目脚手架指南
                        Sam9029
Webpack前端webpack
                        
    **‍‍若此文你认为写的不错，不要吝啬你的赞扬，求收藏，求评论，求一个大大的赞！**由于文章有一万字左右的，故而内容中部分不免冗余，或许有写了些废话进去，但整体也无伤大雅**‍‍文章是初次实践总结,若有错误或某个内容有更优的解决方案，还望指正！**附录中有脚手架文件夹目录大纲（Vue3+Webpack5）脚手架项目源码:https://github.com/sam9029/s9_webpack_g
    
                    
    • 
                    
  • vue3打包 error in node_modules/@types/node/stream/web.d.ts 错误解决办法
                        柒先生~
前端javascript开发语言
                        
    ue3项目打包的时候突然报错，错误如下ERRORFailedtocompilewith1error14:13:57errorinnode_modules/@types/node/stream/web.d.ts:469:56TS1005:'?'expected.467|//IfReportingObservercheckisremoved,thetypeherewillformacircularre
    
                    
    • 
                    
  • vue2与vue3的区别
                        longfan_
vue
                        
    1.vue2和vue3响应式原理发生了改变vue2的响应式原理是利⽤es5的⼀个API，Object.defineProperty()对数据进⾏劫持结合发布订阅模式的⽅式来实现的。vue3中使⽤了es6的proxyAPI对数据代理，通过reactive()函数给每⼀个对象都包⼀层Proxy，通过Proxy监听属性的变化，从⽽实现对数据的监控。这⾥是引相⽐于vue2版本，使⽤proxy的优势如下1.
    
                    
    • 
                    
  • vue.js在js里获取属性，触发vue.js内的方法
                        摸鱼的张三
javascriptvue.jsflutter
                        
    在script标签内把appVue设置varvarappVue=newVue({})appVue不能跨标签也就是说不能这样写varappVue=newVue({})console.log(appVue)上面这个是错的varappVue=newVue({})console.log(appVue)这个是vue2.js的版本这样写可以vue3.js是没有的然后拿到appVue就可以绑定原生事件触发app
    
                    
    • 
                    
  • vue3 el-message组件封装
                        小白小白从不日白
Vue3vue.js前端javascript
                        
    背景在封装请求拦截器时，使用ElMessage进行弹窗提示成功或失败，但是如果页面用到多个接口，这时就会导致页面出现很多弹窗，导致用户体验不好，有可能出现卡顿现象。这时就需要进行一些判断，如果前面的ElMessage还没关闭并且类型是一致的就return，不再弹窗提示，类型不一致时就要弹窗提示类似下面的代码使用elmentui或者element-plus的时候，使用里面的弹窗组件，在同一按钮多次点
    
                    
    • 
                    
  • vue如何获取一个元素的基本信息
                        LJ小番茄
随便写点Vue的那些三两事儿~vue.jsjavascript前端
                        
    PS：代码全部使用Vue3和setup语法糖来写的首先准备HTML结构点击该元素的相关信息获取Vue部分import{onMounted,ref}from"vue";constmyElement=ref(null);constonClick=()=>{console.log('myElement.value.clientWidth='+myElement.value.clientWidth);co
    
                    
    • 
                    
  • ref 和 reactive 区别
                        有一个好名字
Vuevue.jsjavascript前端
                        
    前言ref和reactive是Vue3中响应式编程的核心。在Vue中，响应式编程是一种使数据与UI保持同步的方式。当数据变化时，UI会自动更新，反之亦然。这种机制大大简化了前端开发，使我们能够专注于数据和用户界面的交互，而不必手动处理DOM更新。refref是Vue3中的一个简单响应式API，用于创建一个包装基本数据类型的响应式引用(也可以包装复杂类型，只不过底层还是由reactive的方式实现的
    
                    
    • 
                    
  • Vue3+TypeScript频谱跳动算法（附vue2+JavaScript）
                        I like Code?
javascripttypescript算法
                        
    以下为Vue3+TypeScript频谱跳动算法只需要调用下列方法即可实现，并且设置定时器。（最好每次先清楚，否则可能耗内存）if(updateInterval.value){clearInterval(updateInterval.value);}constupdateInterval=ref(undefined);generateDataSets();updateInterval.value=
    
                    
    • 
                    
  • 重磅算法：通信设备虚拟仿真-波形根据频率、带宽变化算法（Vue3+typescript）结尾附vue2+JavaScript
                        I like Code?
javascript算法typescript
                        
    以下为Vue3+typescriptconstpointSpacing=ref(0);constupdateInterval=ref(undefined);//更新图表数据的函数constUpdateChartTest=(centerFrequnency:number,bandwidth:number,baseFreq=800,baseBW=100)=>{if(updateInterval.val
    
                    
    • 
                                
  • VMware Workstation 11 或者 VMware Player 7安装MAC OS X 10.10 Yosemite
                                    iwindyforest
vmwaremac os10.10workstationplayer
                                    
    最近尝试了下VMware下安装MacOS 系统， 
安装过程中发现网上可供参考的文章都是VMware Workstation 10以下， MacOS X 10.9以下的文章， 
只能提供大概的思路， 但是实际安装起来由于版本问题， 走了不少弯路， 所以我尝试写以下总结， 希望能给有兴趣安装OSX的人提供一点帮助。 
  
  
写在前面的话： 
其实安装好后发现， 由于我的th
    
                                
    • 
                                
  • 关于《基于模型驱动的B/S在线开发平台》源代码开源的疑虑？
                                    deathwknight
JavaScriptjava框架
                                    
    本人从学习Java开发到现在已有10年整，从一个要自学 java买成javascript的小菜鸟，成长为只会java和javascript语言的老菜鸟（个人邮箱：[email protected]） 
 
一路走来，跌跌撞撞。用自己的三年多业余时间，瞎搞一个小东西（基于模型驱动的B/S在线开发平台，非MVC框架、非代码生成）。希望与大家一起分享，同时有许些疑虑，希望有人可以交流下 
 
平台
    
                                
    • 
                                
  • 如何把maven项目转成web项目
                                    Kai_Ge
mavenMyEclipse
                                    
    创建Web工程，使用eclipse ee创建maven web工程 1.右键项目,选择Project Facets,点击Convert to faceted from 2.更改Dynamic Web Module的Version为2.5.(3.0为Java7的,Tomcat6不支持). 如果提示错误,可能需要在Java Compiler设置Compiler compl
    
                                
    • 
                                
  • 主管？？？
                                    Array_06
工作
                                    
    转载：http://www.blogjava.net/fastzch/archive/2010/11/25/339054.html 
 
 
 
 
很久以前跟同事参加的培训，同事整理得很详细，必须得转！ 
 
前段时间，公司有组织中高阶主管及其培养干部进行了为期三天的管理训练培训。三天的课程下来，虽然内容较多，因对老师三天来的课程内容深有感触，故借着整理学习心得的机会，将三天来的培训课程做了一个
    
                                
    • 
                                
  • python内置函数大全
                                    2002wmj
python
                                    
    最近一直在看python的document，打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四个方面，其实在看的时候发现整个《The Python Standard Library》章节都是很不错的，其中描述了很多不错的主题。先把Build-in Fu
    
                                
    • 
                                
  • JSP页面通过JQUERY合并行
                                    357029540
JavaScriptjquery
                                    
    在写程序的过程中我们难免会遇到在页面上合并单元行的情况，如图所示 
 
 
如果对于会的同学可能很简单，但是对没有思路的同学来说还是比较麻烦的，提供一下用JQUERY实现的参考代码 
 
function mergeCell(){ 
        var trs = $("#table tr"); 
&nb
    
                                
    • 
                                
  • Java基础
                                    冰天百华
java基础
                                    
    学习函数式编程 
package base;

import java.text.DecimalFormat;

public class Main {

	public static void main(String[] args) {
//		Integer a = 4;  
//		Double aa = (double)a  / 100000;  
//		Decimal
    
                                
    • 
                                
  • unix时间戳相互转换
                                    adminjun
转换unix时间戳
                                    
    如何在不同编程语言中获取现在的Unix时间戳(Unix timestamp)？     Java time   JavaScript Math.round(new Date().getTime()/1000)
getTime()返回数值的单位是毫秒   Microsoft .NET / C# epoch = (DateTime.Now.ToUniversalTime().Ticks - 62135
    
                                
    • 
                                
  • 作为一个合格程序员该做的事
                                    aijuans
程序员
                                    
    作为一个合格程序员每天该做的事   1、总结自己一天任务的完成情况 最好的方式是写工作日志，把自己今天完成了什么事情，遇见了什么问题都记录下来，日后翻看好处多多 
2、考虑自己明天应该做的主要工作 把明天要做的事情列出来，并按照优先级排列，第二天应该把自己效率最高的时间分配给最重要的工作 
3、考虑自己一天工作中失误的地方，并想出避免下一次再犯的方法 出错不要紧，最重
    
                                
    • 
                                
  • 由html5视频播放引发的总结
                                    ayaoxinchao
html5视频video
                                    
    前言 
  
项目中存在视频播放的功能，前期设计是以flash播放器播放视频的。但是现在由于需要兼容苹果的设备，必须采用html5的方式来播放视频。我就出于兴趣对html5播放视频做了简单的了解，不了解不知道，水真是很深。本文所记录的知识一些浅尝辄止的知识，说起来很惭愧。 
  
视频结构 
  
本该直接介绍html5的<video>的，但鉴于本人对视频
    
                                
    • 
                                
  • 解决httpclient访问自签名https报javax.net.ssl.SSLHandshakeException: sun.security.validat
                                    bewithme
httpclient
                                    
         如果你构建了一个https协议的站点，而此站点的安全证书并不是合法的第三方证书颁发机构所签发，那么你用httpclient去访问此站点会报如下错误 
  
javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path bu
    
                                
    • 
                                
  • Jedis连接池的入门级使用
                                    bijian1013
redisredis数据库jedis
                                    
    Jedis连接池操作步骤如下： 
        a.获取Jedis实例需要从JedisPool中获取； 
        b.用完Jedis实例需要返还给JedisPool； 
        c.如果Jedis在使用过程中出错，则也需要还给JedisPool； 
packag
    
                                
    • 
                                
  • 变与不变
                                    bingyingao
不变变亲情永恒
                                    
    变与不变 
   周末骑车转到了五年前租住的小区，曾经最爱吃的西北面馆、江西水饺、手工拉面早已不在， 
   各种店铺都换了好几茬，这些是变的。 
   三年前还很流行的一款手机在今天看起来已经落后的不像样子。 
   三年前还运行的好好的一家公司，今天也已经不复存在。 
   一座座高楼拔地而起，
    
                                
    • 
                                
  • 【Scala十】Scala核心四：集合框架之List
                                    bit1129
scala
                                    
    Spark的RDD作为一个分布式不可变的数据集合，它提供的转换操作，很多是借鉴于Scala的集合框架提供的一些函数，因此，有必要对Scala的集合进行详细的了解 
  
1. 泛型集合都是协变的，对于List而言，如果B是A的子类，那么List[B]也是List[A]的子类，即可以把List[B]的实例赋值给List[A]变量 
  
2. 给变量赋值(注意val关键字，a，b
    
                                
    • 
                                
  • Nested Functions in C
                                    bookjovi
cclosure
                                    
      
Nested Functions 又称closure，属于functional language中的概念，一直以为C中是不支持closure的，现在看来我错了，不过C标准中是不支持的，而GCC支持。 
  
既然GCC支持了closure，那么 lexical scoping自然也支持了，同时在C中label也是可以在nested functions中自由跳转的
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-WeakHashMap
                                    BrokenDreams
Collections
                                    
            总结这个类之前，首先看一下Java引用的相关知识。Java的引用分为四种：强引用、软引用、弱引用和虚引用。 
 
        
强引用：就是常见的代码中的引用，如Object o = new Object();存在强引用的对象不会被垃圾收集
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-解释器模式-Interpret
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 

package design.pattern;

/*
 * 解释器（Interpreter）模式的意图是可以按照自己定义的组合规则集合来组合可执行对象
 * 
 * 代码示例实现XML里面1.读取单个元素的值 2.读取单个属性的值
 * 多
    
                                
    • 
                                
  • After Effects操作&快捷键
                                    cherishLC
After Effects
                                    
    1、快捷键官方文档 
 
 
 中文版：https://helpx.adobe.com/cn/after-effects/using/keyboard-shortcuts-reference.html  
 英文版：https://helpx.adobe.com/after-effects/using/keyboard-shortcuts-reference.html  
 
 
 2、常用快捷键
    
                                
    • 
                                
  • Maven 常用命令
                                    crabdave
maven
                                    
    Maven 常用命令 
  
mvn archetype:generate 
mvn install 
mvn clean 
mvn clean complie 
mvn clean test 
mvn clean install 
mvn clean package 
mvn test 
mvn package 
mvn site 
  
mvn dependency:res
    
                                
    • 
                                
  • shell bad substitution
                                    daizj
shell脚本
                                    
    #!/bin/sh 
 
/data/script/common/run_cmd.exp 192.168.13.168 "impala-shell -islave4 -q 'insert OVERWRITE table imeis.${tableName} select ${selectFields}, ds, fnv_hash(concat(cast(ds as string), im
    
                                
    • 
                                
  • Java SE 第二讲（原生数据类型 Primitive Data Type）
                                    dcj3sjt126com
java
                                    
    Java SE  第二讲： 
 
1.   Windows: notepad, editplus, ultraedit, gvim 
Linux: vi, vim, gedit 
 
2.   Java 中的数据类型分为两大类： 
1）原生数据类型  （Primitive Data Type） 
2）引用类型（对象类型）  （R
    
                                
    • 
                                
  • CGridView中实现批量删除
                                    dcj3sjt126com
PHPyii
                                    
    1，CGridView中的columns添加 
array(
                        'selectableRows' => 2,
                        'footer' => '<button type="button" onclick="GetCheckbox();" style=&
    
                                
    • 
                                
  • Java中泛型的各种使用
                                    dyy_gusi
java泛型
                                    
    Java中的泛型的使用：1.普通的泛型使用 
在使用类的时候后面的<>中的类型就是我们确定的类型。 
public class MyClass1<T> {//此处定义的泛型是T
    private T var;

    public T getVar() {
        return var;
    }

    public void setVa
    
                                
    • 
                                
  • Web开发技术十年发展历程
                                    gcq511120594
Web浏览器数据挖掘
                                    
    回顾web开发技术这十年发展历程： 
Ajax 
03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。 
彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
    
                                
    • 
                                
  • openSession()与getCurrentSession()区别：
                                    hetongfei
javaDAOHibernate
                                    
    来自 http://blog.csdn.net/dy511/article/details/6166134 
1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。 
2. getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭。 
这里getCurrentSession本地事务(本地
    
                                
    • 
                                
  • 第一章 安装Nginx+Lua开发环境
                                    jinnianshilongnian
nginxluaopenresty
                                    
    首先我们选择使用OpenResty，其是由Nginx核心加很多第三方模块组成，其最大的亮点是默认集成了Lua开发环境，使得Nginx可以作为一个Web Server使用。借助于Nginx的事件驱动模型和非阻塞IO，可以实现高性能的Web应用程序。而且OpenResty提供了大量组件如Mysql、Redis、Memcached等等，使在Nginx上开发Web应用更方便更简单。目前在京东如实时价格、秒
    
                                
    • 
                                
  • HSQLDB In-Process方式访问内存数据库
                                    liyonghui160com

                                    
      
  
HSQLDB一大特色就是能够在内存中建立数据库，当然它也能将这些内存数据库保存到文件中以便实现真正的持久化。 
  
先睹为快！ 
  
下面是一个In-Process方式访问内存数据库的代码示例： 
  
  
下面代码需要引入hsqldb.jar包 （hsqldb-2.2.8） 
  
import java.s
    
                                
    • 
                                
  • Java线程的5个使用技巧
                                    pda158
java数据结构
                                    
    Java线程有哪些不太为人所知的技巧与用法？   　　萝卜白菜各有所爱。像我就喜欢Java。学无止境，这也是我喜欢它的一个原因。日常 
工作中你所用到的工具，通常都有些你从来没有了解过的东西，比方说某个方法或者是一些有趣的用法。比如说线程。没错，就是线程。或者确切说是Thread这个类。当我们在构建高可扩展性系统的时候，通常会面临各种各样的并发编程的问题，不过我们现在所要讲的可能会略有不同。   
    
                                
    • 
                                
  • 开发资源大整合：编程语言篇——JavaScript（1）
                                    shoothao
JavaScript
                                    
    概述：本系列的资源整合来自于github中各个领域的大牛，来收藏你感兴趣的东西吧。           
  程序包管理器  
  管理javascript库并提供对这些库的快速使用与打包的服务。 
 
  Bower - 用于web的程序包管理。 
  component - 用于客户端的程序包管理，构建更好的web应用程序。 
  spm - 全新的静态的文件包管
    
                                
    • 
                                
  • 避免使用终结函数
                                    vahoa.ma
javajvmC++
                                    
    终结函数（finalizer）通常是不可预测的，常常也是很危险的，一般情况下不是必要的。使用终结函数会导致不稳定的行为、更差的性能，以及带来移植性问题。不要把终结函数当做C++中的析构函数（destructors）的对应物。 
  
    我自己总结了一下这一条的综合性结论是这样的： 
1）在涉及使用资源，使用完毕后要释放资源的情形下，首先要用一个显示的方
    
                                
    •