程序员七哥
程序员七哥

Spring容器的基本实现之源码分析-下篇

​ 本文接着上一篇 《Spring容器的基本实现之源码分析-上篇》 接着来继续分析 Spring容器启动流程。

​ 本篇将会讨论 Spring 启动流程中剩下的几个核心方法， 包括 BeanFactory 后处理、初始化非延迟加载单例、finishRefresh这几个方法的具体流程。

下篇目录：


下篇目录.png

BeanFactory 的后处理

​ BeanFactory 作为 Spring 中容器功能的基础，用于存放所有已加载的 bean ，为了保证程序的高度可扩展， Spring 针对 BeanFactory 做了大量的扩展，比如我们熟知的 PostProcessor 等都是在这里实现的。

激活注册的BeanFactoryPostProcessor

​ 首先我们先了解下BeanFactoryPostProcessor的用法。简单来说 BeanFactoryPostProcessor 和前面说的BeanPostProcessor类似，可以对bean的定义（配置元数据） 进行处理。那么它们之前的区别是什么呢？

简单来说，SpringIOC 允许BeanFactoryPostProcessor 在容器实际实例化任何其他的bean之前读取配置的元数据，它的作用于是容器级的，如果是想改变实际的bean实例，那么最好还是使用 BeanPostProcessor 。在 Spring中存在对于 BeanFactoryPostProcessor 的典型应用，比如 PropertyPlaceholderConfigurer。

  1. BeanFactoryPostProcessor 的典型应用： PropertyPlaceholderConfigurer

    我们在配置Spring的Bean描述文件时，经常会使用属性变量引用：

    这种使用变量的方式，就是Spring的分散配置，可以在另外的配置文件中为 bean.message 指定值。如在 bean.properties 文件中指定：

    bean.message=Hello World!

    当访问bean时，其属性就会被置为配置的字符串，但问题是Spring怎样知道存在这样的配置文件呢？ 这就要靠 PropertyPlaceholderConfigurer 这个类的bean：

        
        
            
                config/bean.properties

在这个bean中指定了配置文件为 config/bean.properties ，这里我们似乎明白了，但仔细想一下，这个"msgHandler" 只是配置为Spring管理的一个 Bean，并没有被别的bean或者对象引用，Spring 的 BeanFactory 怎样知道要从这个 bean中获取配置信息呢？

​ 查看 PropertyPlaceholderConfigurer 的层次结构，可以看到这个类间接继承了 BeanFactoryPostProcessor 接口。这是一个很特别的接口，当Spring加载任何实现了这个接口的bean的配置时，都会在 bean 工厂载入所有bean 的配置之后执行 postProcessorBeanFactory 方法。在 PropertyResourceConfigurer 类中实现了postProcessorBeanFactory 方法，在方法中先后调用了 mergeProperties、 convertProperties、 processProperties这三个方法，分别得到配置，将得到的配置转换为合适的类型，最后将配置的内容告知BeanFactory。

PlaceholderConfigurerSupport层级.jpg 
@Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        try {
            Properties mergedProps = mergeProperties();

            // Convert the merged properties, if necessary.
            convertProperties(mergedProps);

            // Let the subclass process the properties.
            processProperties(beanFactory, mergedProps);
        }
        catch (IOException ex) {
            throw new BeanInitializationException("Could not load properties", ex);
        }
    }

​ 正是通过实现 BeanFactoryPostProcessor 接口， BeanFactory 会在实例化任何 bean 之前获得配置信息，从而能够正确解析 bean 描述文件中的变量引用。

  1. 使用自定义的 BeanFactoryPostProcessor

    我们实现一个 BeanFactoryPostProcessor ,去除潜在的‘流氓’属性值来展示自定义 BeanFactoryPostProcessor 的创建和使用，例如在 bean 定义中留下 bollocks 这样的字眼。

    配置文件 beans.xml

    
        
            
                bollocks
                winky
                bum
                MicroSoft

​ ObScenityRemovingBeanFactoryPostProcessor.java

​

public class ObScenityRemovingBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    private Set obscenties;

    public ObScenityRemovingBeanFactoryPostProcessor() {
        this.obscenties = new HashSet<>();
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        String [] beanNames = beanFactory.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            StringValueResolver stringValueResolver = strVal -> {
                if (isObscene(strVal)) {
                    return "*****";
                }
                return strVal;
            };
            BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(stringValueResolver);
            visitor.visitBeanDefinition(beanDefinition);
        }
    }

    public boolean isObscene (Object val) {
        String potentialObscenity = val.toString().toUpperCase();
        return this.obscenties.contains(potentialObscenity);
    }

    public void setObscenties(Set obscenties) {
        this.obscenties.clear();
        for (String obscenity : obscenties) {
            this.obscenties.add(obscenity.toUpperCase());
        }
    }
}

测试类

    @Test
    public void testObscenityPostProcessor() {
        ConfigurableListableBeanFactory bf = new XmlBeanFactory(new ClassPathResource("beans.xml"));
        BeanFactoryPostProcessor beanFactoryPostProcessor = (BeanFactoryPostProcessor) bf.getBean("bfpp");
        beanFactoryPostProcessor.postProcessBeanFactory(bf);
        System.out.println(bf.getBean("simple"));
    }

输出结果

SimplePostProcessor{connectString='*****', password='*****', username='imaginecup'}

通过自定义的 BeanFactoryPostProcessor Spring 很好的实现了屏蔽掉 obscenties 定义的不应该展示的属性。

  1. 激活 BeanFactoryPostProcessor

    上面了解了 BeanFactoryPostProcessor 的用法之后我们在深入研究其调用过程。

public static void invokeBeanFactoryPostProcessors(
         ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

     // Invoke BeanDefinitionRegistryPostProcessors first, if any.
     Set processedBeans = new HashSet();
         // 对 BeanDefinitionRegistry 类型的处理
     if (beanFactory instanceof BeanDefinitionRegistry) {
         BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
         List regularPostProcessors = new LinkedList();
         List registryProcessors = new LinkedList();
         // 硬编码注册的后处理器
         for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
             if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                 BeanDefinitionRegistryPostProcessor registryProcessor =
                         (BeanDefinitionRegistryPostProcessor) postProcessor;
                      // 对于BeanDefinitionRegistryPostProcessor类型的，在BeanFactoryPostProcessor的基础上还有自己定义的方法，需要先调用
                 registryProcessor.postProcessBeanDefinitionRegistry(registry);
                 registryProcessors.add(registryProcessor);
             }
             else {
                      // 记录常规的BeanFactoryPostProcessor
                 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.
             // 配置注册的后置处理器
         String[] postProcessorNames =
                 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
         for (String ppName : postProcessorNames) {
                  // 先调用实现了PriorityOrdered 接口的
             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                 processedBeans.add(ppName);
             }
         }
         sortPostProcessors(currentRegistryProcessors, beanFactory);
         registryProcessors.addAll(currentRegistryProcessors);
             // BeanDefinitionRegistryPostProcessor的特殊处理
         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
         currentRegistryProcessors.clear();

         // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
         postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
         for (String ppName : postProcessorNames) {
                  // 接下来调用 实现了Ordered 接口的
             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);
         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) {
                      // 处理剩余的BeanDefinitionRegistryPostProcessors，直到没有
                 if (!processedBeans.contains(ppName)) {
                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                     processedBeans.add(ppName);
                     reiterate = true;
                 }
             }
             sortPostProcessors(currentRegistryProcessors, beanFactory);
             registryProcessors.addAll(currentRegistryProcessors);
             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
             currentRegistryProcessors.clear();
         }

         // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
             // 激活BeanDefinitionRegistryPostProcessor的postProcessBeanFactory，之前激活的是postProcessBeanDefinitionRegistry
         invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
             // 激活硬编码注册的常规postProcessors
         invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
     }

     else {
         // Invoke factory processors registered with the context instance.
             // bean工厂非BeanDefinitionRegistry，激活硬编码的beanFactoryPostProcessors
         invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
     }

     // Do not initialize FactoryBeans here: We need to leave all regular beans
     // uninitialized to let the bean factory post-processors apply to them!
         // 对于配置中读取的BeanFactoryPostProcessor的处理
     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接口的 按照优先级进行排序
     sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
     invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

     // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
         // 按照order进行排序
     List orderedPostProcessors = new ArrayList();
     for (String postProcessorName : orderedPostProcessorNames) {
         orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
     }
     sortPostProcessors(orderedPostProcessors, beanFactory);
     invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

     // Finally, invoke all other BeanFactoryPostProcessors.
     List nonOrderedPostProcessors = new ArrayList();
     for (String postProcessorName : nonOrderedPostProcessorNames) {
         nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
     }
         // 无序，直接调用
     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();
 }

从上面的方法中我们发现，对于 BeanFactoryPostProcessor 的处理分为两种情况进行：

一种是 ConfigurableListableBeanFactory 属于 BeanDefinitionRegistry ，则需要处理 BeanDefinitionRegistryPostProcessor，另外一种是 beanFactory 不属于 BeanDefinitionRegistry 则只需要处理 BeanFactoryPostProcessor。而对于这两种情况 则都需要考虑硬编码注册的后置处理器以及通过配置注册的后置处理器。

这里我们一起看下 BeanDefinitionRegistry 类型的处理过程，因为非BeanDefinitionRegistry 类型的只需要进行普通BeanFactoryPostProcessor 的处理。

（1）对于硬编码注册的后置处理器，主要是通过 AbstractApplicationContext 中添加后置处理器的方法 addBeanFactoryPostProcessor 进行添加：

 public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
     Assert.notNull(postProcessor, "BeanFactoryPostProcessor must not be null");
     this.beanFactoryPostProcessors.add(postProcessor);
 }

添加的后处理器被放在beanFactoryPostProcessors 中，而在调用处理 BeanFactoryPostProcessor 时会判断beanFactoryPostProcessors 是否有数据。由于 BeanDefinitionRegistryPostProcessor 继承自 BeanFactoryPostProcessor ，因此它不但有 BeanFactoryPostProcessor 的特性同时还有自定义的个性化方法，所以这里需要从beanFactoryPostProcessors 中过滤出BeanDefinitionRegistryPostProcessor 类型的后处理器，进行其个性化方法 postProcessBeanDefinitionRegistry 的调用。

（2）记录后处理器使用了两个List。 registryProcessors 记录 BeanDefinitionRegistryPostProcessor 这种特殊的后处理器，regularPostProcessors 记录通过硬编码注册的BeanFactoryPostProcessor 类型的处理器。

（3） 将通过配置注册的 BeanDefinitionRegistryPostProcessor 按照优先级排序并调用postProcessBeanDefinitionRegistry 然后加入到registryProcessors 这个List中。对于这两个List进行统一的调用 BeanFactoryPostProcessor 类的 postProcessBeanFactory方法。

（4） 通过配置注册的普通BeanFactoryPostProcessor 处理。和BeanDefinitionRegistryPostProcessor 处理流程类似。

BeanDefinitionRegistryPostProcessor 只对 BeanDefinitionRegistry 类型的beanFactory有效，所以如果 beanFactory 并不是 BeanDefinitionRegistry 类型，则只需要处理 BeanFactoryPostProcessor ，包括硬编码注册和配置注册的后处理器。

认真看的同学会发现，对于硬编码方法注册的 BeanFactoryPostProcessor 不需要作任何排序，但是在配置文件中读取的处理器，Spring并不会保证读取的顺序。所以为了保证用户的调用顺序的要求，Spring对于后处理器的调用支持按照PriorityOrdered 或者Ordered的调用顺序。

注册BeanPostProcessor

​ 上面我们提到了 BeanFactoryPostProcessor 的调用，这一节我们学习 BeanPostProcessor ，但是这里并不是调用而是注册。真正的调用其实是在 bean 的实例化阶段。这是一个很重要的步骤，由于不调用后处理器导致很多功能 BeanFactory 不支持。

​ 下面我们继续探讨 registerBeanPostProcessors 的方法实现。

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

        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) {
            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.
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

        // Next, register the BeanPostProcessors that implement Ordered.
        List orderedPostProcessors = new ArrayList();
        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();
        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.
        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).
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    }

BeanFactoryPostProcessor 和 BeanPostProcessor 两者之间区别不大，感兴趣的可以再看下上面代码，相信不难看懂。

初始化消息资源

这里主要进行国际化处理，即常见的多语言app，需要按照客户端的语言返回不同的页面 。 Spring 定义了访问国际化信息的 MessageSource 接口，并提供了几个易用的实现类。 Message 接口分别被 HierarchicalMessageSource 和ApplicationContext 接口扩展。

    protected void initMessageSource() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
            this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
            // Make MessageSource aware of parent MessageSource.
            if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
                if (hms.getParentMessageSource() == null) {
                    // Only set parent context as parent MessageSource if no parent MessageSource
                    // registered already.
                    hms.setParentMessageSource(getInternalParentMessageSource());
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Using MessageSource [" + this.messageSource + "]");
            }
        }
        else {
            // Use empty MessageSource to be able to accept getMessage calls.
            DelegatingMessageSource dms = new DelegatingMessageSource();
            dms.setParentMessageSource(getInternalParentMessageSource());
            this.messageSource = dms;
            beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                        "': using default [" + this.messageSource + "]");
            }
        }
    }

初始化ApplicationEventMulticaster

​ 在开始研究 Spring 的时间传播器之前，我们先来看一个 Spring 的事件监听的简单用法。

  1. 定义监听事件。

    public class TestEvent extends ApplicationEvent{

    public String msg;

    /**
     * Create a new ApplicationEvent.
     *
     * @param source the object on which the event initially occurred (never {@code null})
     */
    public TestEvent(Object source) {
        super(source);
    }

    public TestEvent(Object source,String msg) {
        super(source);
        this.msg = msg;
    }

    public void print() {
        System.out.println(msg);
    }
}

  1. 定义监听器

    public class TestListener implements ApplicationListener{

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof TestEvent) {
            TestEvent testEvent = (TestEvent) event;
            testEvent.print();
        }
    }
}

  2. 添加配置文件

  1. 测试

        @Test
    public void testEvent() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        TestEvent testEvent = new TestEvent("hello","msg");
        applicationContext.publishEvent(testEvent);
    }

当程序运行时，Spring 会将发出的 TestEvent 事件转给我自定义的 TestLinstener 进行进一步处理。

相信很多人看到这里，一下子会想到了观察者模式，这确实是个典型的应用，可以在比较关心的事件结束后及时进行处理。那么我们接下来一起看看 ApplicationEventMulticaster 是如何被初始化的，以确保功能的正确运行。

initApplicationEventMulticaster 的方式比较简单，无非考虑两种情况。

  • 如果用户自定义了事件广播器则使用自定义的广播器。
  • 如果用户没有自定义的事件广播器，则使用默认的 ApplicationEventMulticaster。
protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
            this.applicationEventMulticaster =
                    beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
            }
        }
        else {
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                        APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                        "': using default [" + this.applicationEventMulticaster + "]");
            }
        }
    }

按照之前我们了解的事件监听的顺序和逻辑，我们推断，作为广播器，一定是用于存放监听器并在合适的时候调用监听器，那么我们不妨进入默认的广播器实现 SimpleApplicationEventMulticaster 来一探究竟。

下面这段代码是关键所在：

    @Override
    public void multicastEvent(ApplicationEvent event) {
        multicastEvent(event, resolveDefaultEventType(event));
    }

    @Override
    public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        for (final ApplicationListener listener : getApplicationListeners(event, type)) {
            Executor executor = getTaskExecutor();
            if (executor != null) {
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        invokeListener(listener, event);
                    }
                });
            }
            else {
                invokeListener(listener, event);
            }
        }
    }

可以看到，当产生Spring 事件的时候会默认使用 SimpleApplicationEventMulticaster 的 multicastEvent 方法来广播事件，遍历所有监听器，并使用监听器中的 onApplicationEvent 方法来进行监听器处理。

注册监听器

​ 上面在学习 Spring 广播器的时候反复提到了事件监听器，那么在 Spring注册监听器的时候又做了哪些逻辑操作呢？

protected void registerListeners() {
        // Register statically specified listeners first.
         // 硬编码方式注册的监听器处理
        for (ApplicationListener listener : getApplicationListeners()) {
            getApplicationEventMulticaster().addApplicationListener(listener);
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let post-processors apply to them!
        // 配置文件注册的监听器处理
        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
        for (String listenerBeanName : listenerBeanNames) {
            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        // Publish early application events now that we finally have a multicaster...
        // 由于上一步初始化了广播器，那么就开始派发早期的事件吧
        Set earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (earlyEventsToProcess != null) {
            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }
    }

初始化非延迟加载单例

​ 完成 BeanFactory 的初始化工作，其中包括 ConversionService 的设置、配置冻结 以及 非延迟加载的 bean 的初始化工作。

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

        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
                @Override
                public String resolveStringValue(String strVal) {
                    return getEnvironment().resolvePlaceholders(strVal);
                }
            });
        }

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

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

        // Allow for caching all bean definition metadata, not expecting further changes.
        // 冻结所有 bean 定义，说明注册的bean定义将不被修改或任何进一步的处理
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons.
        // 初始化剩下的所有非延迟加载的单实例bean
        beanFactory.preInstantiateSingletons();
    }

  1. ConversionService 的设置

    Spring提供了一种类型转换方式：使用converter，比如将String 转换为 Date。下面我们使用一个简单的示例来了解下 Converter 的使用方式。

    （1） 定义转换器

    public class String2DateConverter implements Converter {
    @Override
    public Date convert(String source) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf.parse(source);
            return date;
        } catch (Exception e) {
            return null;
        }
    }
}

    (2) 注册

    (3) 测试

         @Test
    public void testString2DateConvert() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        DefaultConversionService conversionService = (DefaultConversionService) applicationContext.getBean("conversionService");
        conversionService.addConverter(new String2DateConverter());
        String dateStr = "2019-02-21";
        Date date = conversionService.convert(dateStr,Date.class);
        System.out.println(date);
    }

    通过以上功能我们看到了 Converter 和 ConversionService 提供的便利功能，其中的配置就是在当前函数中初始化的。

  1. 冻结配置

    冻结所有bean的定义，说明注册的bean定义将不再做任何修改或进行任何一进步的处理。

     @Override
 public void freezeConfiguration() {
     this.configurationFrozen = true;
     this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
 }

  1. 初始化非延迟加载

    ApplicationContext 实现的默认行为就是在启动时将所有的单例 bean 提前实例化。 提前实例化意味着作为初始化过程的一部分， ApplicationContext 实例会创建并配置所有的单例 bean。通常情况下这是一件好事，因为这样在配置中的任何错误就会被即刻发现（否则可能要花几个小时甚至几天）。 而这个实例化的过程就是在 preInstantiateSingletons 中完成的。

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

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

     // Trigger initialization of all non-lazy singleton beans...
     for (String beanName : beanNames) {
         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
             if (isFactoryBean(beanName)) {
                 final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
                 boolean isEagerInit;
                 if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                     isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
                         @Override
                         public Boolean run() {
                             return ((SmartFactoryBean) factory).isEagerInit();
                         }
                     }, getAccessControlContext());
                 }
                 else {
                     isEagerInit = (factory instanceof SmartFactoryBean &&
                             ((SmartFactoryBean) factory).isEagerInit());
                 }
                 if (isEagerInit) {
                     getBean(beanName);
                 }
             }
             else {
                 getBean(beanName);
             }
         }
     }

     // Trigger post-initialization callback for all applicable beans...
     for (String beanName : beanNames) {
         Object singletonInstance = getSingleton(beanName);
         if (singletonInstance instanceof SmartInitializingSingleton) {
             final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
             if (System.getSecurityManager() != null) {
                 AccessController.doPrivileged(new PrivilegedAction() {
                     @Override
                     public Object run() {
                         smartSingleton.afterSingletonsInstantiated();
                         return null;
                     }
                 }, getAccessControlContext());
             }
             else {
                 smartSingleton.afterSingletonsInstantiated();
             }
         }
     }
 }
 


    finishRefresh
    

    ​ 在 Spring 中提供了 LifeCycle 接口， LifeCycle 中包含start/stop 方法，实现此接口后Spring 会保证在启动的时候调用 start 方法开始生命周期，并在 Spring 关闭的时候调用 stop 方法来结束生命周期，通常用来配置后台程序，再启动后一直运行（如对MQ进行轮询等）。而 ApplicationContext 的初始化最后正是保证了这一功能的实现。
    

        protected void finishRefresh() {
        // Initialize lifecycle processor for this context.
        initLifecycleProcessor();

        // Propagate refresh to lifecycle processor first.
        getLifecycleProcessor().onRefresh();

        // Publish the final event.
        publishEvent(new ContextRefreshedEvent(this));

        // Participate in LiveBeansView MBean, if active.
        LiveBeansView.registerApplicationContext(this);
    }

    

      

    1.  
      initLifecycleProcessor
       
      当ApplicationContext 启动或停止时，它会通过LifeCycleProcessor来与所有生命的 bean 的周期做状态更新，而在LifeCycleProcessor 的使用前首先需要进行初始化。
       
      2. 

    

    protected void initLifecycleProcessor() {
     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
     if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
         this.lifecycleProcessor =
                 beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
         if (logger.isDebugEnabled()) {
             logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
         }
     }
     else {
         DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
         defaultProcessor.setBeanFactory(beanFactory);
         this.lifecycleProcessor = defaultProcessor;
         beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
         if (logger.isDebugEnabled()) {
             logger.debug("Unable to locate LifecycleProcessor with name '" +
                     LIFECYCLE_PROCESSOR_BEAN_NAME +
                     "': using default [" + this.lifecycleProcessor + "]");
         }
     }
 }

    

      

    1.  
      OnRefresh
       
      启动所有实现了 LifeCycle 接口的 bean。
       
      2. 

    

     @Override
 public void onRefresh() {
     startBeans(true);
     this.running = true;
 }
 
 
 private void startBeans(boolean autoStartupOnly) {
     Map lifecycleBeans = getLifecycleBeans();
     Map phases = new HashMap();
     for (Map.Entry entry : lifecycleBeans.entrySet()) {
         Lifecycle bean = entry.getValue();
         if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
             int phase = getPhase(bean);
             LifecycleGroup group = phases.get(phase);
             if (group == null) {
                 group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
                 phases.put(phase, group);
             }
             group.add(entry.getKey(), bean);
         }
     }
     if (!phases.isEmpty()) {
         List keys = new ArrayList(phases.keySet());
         Collections.sort(keys);
         for (Integer key : keys) {
             phases.get(key).start();
         }
     }
 }

    

      

    1.  
      publishEvent
       
      当完成ApplicationContext初始化的时候，要通过 Spring 中的事件发布机制来发布 ContextRefreshedEvent 事件，以保证对应的监听器可以做进一步的逻辑处理。
       
      2. 

    

    protected void publishEvent(Object event, ResolvableType eventType) {
     Assert.notNull(event, "Event must not be null");
     if (logger.isTraceEnabled()) {
         logger.trace("Publishing event in " + getDisplayName() + ": " + event);
     }

     // Decorate event as an ApplicationEvent if necessary
     ApplicationEvent applicationEvent;
     if (event instanceof ApplicationEvent) {
         applicationEvent = (ApplicationEvent) event;
     }
     else {
         applicationEvent = new PayloadApplicationEvent(this, event);
         if (eventType == null) {
             eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
         }
     }

     // Multicast right now if possible - or lazily once the multicaster is initialized
     if (this.earlyApplicationEvents != null) {
         this.earlyApplicationEvents.add(applicationEvent);
     }
     else {
         getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
     }

     // Publish event via parent context as well...
     if (this.parent != null) {
         if (this.parent instanceof AbstractApplicationContext) {
             ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
         }
         else {
             this.parent.publishEvent(event);
         }
     }
 }


    至此，Spring 容器就启动完毕了，相信大家仔细看完这两篇文章一定会对 Spring 的原理有更进一步的了解。
    

    传送门：
    

    《Spring容器的基本实现之源码分析-上篇》
    






    



    


    


    




    

    你可能感兴趣的:(Spring容器的基本实现之源码分析-下篇)
    

    

    

      

    • 美易官方：盘前道指期货涨0.5%，游戏驿站跌逾15%
美股投资
财经人工智能大数据新浪微博微信微信公众平台百度金融

      在股市开盘前的交易时段，道指期货上涨了0.5%，而游戏驿站（GameStop）的股价却出现了大幅下跌，跌幅超过15%。这一市场动态引发了投资者的广泛关注，也反映了当前股市的复杂性和不确定性。美股股指期货周三盘前走强，交易员为季度末的再平衡做准备。本周因假期而缩短，美国将公布关键通胀数据。道指期货涨0.5%，标普500指数期货涨0.6%，纳指期货涨0.5%。德国DAX指数涨0.4%，英国富时100指
      

      • 

    • 亲亲往这里来
神道仙灵

      图片发自App…哈…哈……上次……失误…失误……此…次……哈…哈…哈……我不会……哪么……大舌头……哪么……呆笨……直…白…了…！…亲们……看见…我口中……喝的…啥了么……呵…呵…呵……看见…我手上……又…拿的……啥了…么……哈…哈…哈……哈我的小宝贝
      

      • 

    • 别人能伤害你，是你允许的。
1125198e6b7d

      不要对别人抱有太大期望，保护自己的最佳方式,就是从不高估自己在别人心中的份量。能伤害你的从来不是别人的无情，而是你心存幻想的坚持。及时止损，不盼望就不会失望。相识很久的关系，明明内心很不舒服，却还要装作若无其事的样子，强撑着去面对。一次又一次为了迎合而迎合，自我qipian，精神内耗。对于那些不能带给你任何积极能量的人，我们真正要做的就是及时止损。伤害你的人从来没想过帮助你成长，真正让你成长的是你
      

      • 

    • 2023-02-16
执剑饮烈酒

      1、开心点，反正谁也别想活着离开这个世界。——朱德庸2、我一直以为爱的反义词是不爱，直到现在我才明白，爱的反义词是遗忘。——《寻梦环游记》3、人生的最高境界是佛为心，道为骨，儒为表，大度看世界。技在手，能在身，思在脑，从容过生活。——南怀瑾4、如果一个民族沦落到，只剩下把升官发财当成最终目标和追求的时候，那么这个民族就危险了，一旦金钱和权利成了唯一的信仰，那将是悲哀的。——鲁迅5、人和人如果不在一
      

      • 

    • 为什么wal会 提升数据库性能
浩澜大大
数据库

      由于对于一个数据库内会存在很多张表，那么当数据库更新表数据时（1）直接写入磁盘实际写入的位置，会根据表的不同对应到不同的磁盘位置，在写入数据的时候，就会不停的寻找磁盘地址，找到地址后再去写入，对于机械硬盘来说，无规律的寻址是非常耗时的，对应SSD来说虽然性能提升很多，但是也会消耗时间；（2）先写入日志，在写入磁盘（WAL）WAL的过程，由于总是按照在文件末尾追加，只要找到文件写入位置，写入修改后，
      

      • 

    • 【Python】一文详细介绍 py格式 文件
高斯小哥
Python基础【高质量合集】python新手入门学习

      【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
      

      • 

    • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情
迷影咖啡

      作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
      

      • 

    • 迎接2019
唯有杜康1994

      告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
      

      • 

    • 亲子日记之祝姑姥姥生日快乐（282）
冰心雨露_d504

      2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
      

      • 

    • 100天30本书读书计划（2018-06-11）DAY 62
一个姜姜

      【书名】当我谈跑步时，我谈些什么【作者】村上春树【读书页数】51--128/187【读书时间】2018年6月11日【精彩句子】01肌肉难长，易消。赘肉易长，难消。P5502肌肉也同有血有肉的动物一般无二，它也愿意过更舒服的日子，不继续给它负荷，它便会心安理得地将记忆出去。想再度输入的话，必须得从头开始，将同样的模式重复一遍。P7703不管怎样，反正得坚持跑步。每天跑步对我来说好比生命线，不能说忙就
      

      • 

    • 植物小记
番茄秧子

      小时候，我养过一院子的花。今年，我重新开始从头开始养一点儿植物。别人说那也只是别人说临到快过年，我逛了一趟花市，买了两棵水仙花。路过另外一个卖水仙的摊位，霸气的卖花小妹瞧了一眼我捧着的那两棵弱小，说了一句：“你那个水仙不行，都不会开花的。”以我的脾气，这当然不能相信啊。结果，带回家好几天没动静。某一天早晨起来，两棵水仙悄不吭声全开了，然后香了屋子好多天。水仙三月，我在花市扛了一盆栀子花，花店老板见
      

      • 

    • 大学播音主持都学什么内容？播音主持专业学什么？
配音新手圈

      有些喜欢播音主持并且犹豫要不要报考这个大学专业的小伙伴们就会想要了解大学播音主持都学什么内容吧，毕竟如果不够了解就直接选择这个专业真的等选择完进去学习以后才知道这个专业并不是自己想要学习的东西那就来不及了。下面是小编为大家整理出来的一些播音主持专业学习的内容，请往下看吧。大学播音主持专业主要学习的课程有：播音发声、播音创作基础、广播播音主持、电视播音主持、文艺作品演播学概论、新闻学概论、新闻采编、
      

      • 

    • Android和IOS应用开发-Flutter应用让屏幕在 app 运行期间保持常亮的方法
江上清风山间明月
FlutterandroidiosflutterKeepAlive屏幕常亮wakelock熄屏

      文章目录Flutter应用让屏幕在app运行期间保持常亮的方法方法一：使用系统插件方法二：使用Widgets注意事项Flutter应用让屏幕在app运行期间保持常亮的方法在Flutter开发中，可以使用以下两种方法让屏幕在app运行期间保持常亮：方法一：使用系统插件Flutter社区中已经有很多相关插件可供使用，比如wakelock:https://pub.dev/packages/wakeloc
      

      • 

    • 微信小程序监听用户经纬度变化
某公司摸鱼前端
微信小程序小程序

      一些打卡App需要根据用户的位置来完成打卡那么就需要监听用户位置变化情况：示例：//在某个生命周期函数中，如onLoad中onLoad:function(options){//开始监听位置变化wx.startLocationUpdate({success:function(){console.log('开始更新位置');},fail:function(){console.log('开始更新位置失败
      

      • 

    • 2019-04-08早
梦雅的简动力

      在上瑜伽课前10分钟的调息中，你的眼睛为什么总是想睁开？（焦虑）。你的眉头为什么总是紧锁？（压力）。练习体式时你为什么总是去看别人？（攀比）保持体式时你为什么总是烦躁？（性急）。保持长久而规律的练习，以上这些，终归离你远去。瑜伽，首先，不是帮你得到，而是教你放下。图片发自App时间，一时间无法跳离这个特殊的词汇毅力，坚持，真诚，需要时间来见证真相，现实，伪装，时间自然会揭秘珍惜它又害怕它可它丝毫不
      

      • 

    • 3/31总结
静心第一

      今日总结：1.上午体验课以及反馈2.p1专注力上课3.情绪精品营上课4.燕子营队辅营以及前台值班5.活动室带孩子接待带到访今日反思：1.合理安排体力2.对于准客户记得跟进3.不要放过每一次成交的机会（这个精品营转发有点失败，后期需调整）今日感受：1.为了效果，后期课程一定想方设法布置家庭，给予一个好的支持系统2.上到下午的课程感觉特别特别的累3.晚上在做辅营一个孩子大声叫喊，后来单独出去沟通，其实
      

      • 

    • 极狐GitLab 论坛 2.0 全新上线，可以在论坛上查找与 GitLab 相关的问题了～
极小狐
gitlab极狐GitLabdevopsGitLabci/cddevsecopsSCM

      安装出现依赖错误？版本升级搞不定？遇到422、500就懵逼了？不知道某个功能是免费or付费？……使用GitLab这种全球顶级的DevOps平台进行软件研发时，总会遇到一些困惑，想跟专业的技术人员快速交流以便获得答案，同时又想把这些问题沉淀下来以帮助他人？有这种赠人玫瑰，手有余香的解决方案吗？答案肯定有：论坛！！！论坛——一个各路大神聚集的地方，一个可以解惑答疑问道的地方。解惑：搜索与自己问题相同或
      

      • 

    • 数据结构奇妙旅程之深入解析快速排序
山间漫步人生路
数据结构排序算法算法

      快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
      

      • 

    • 被隔离的日子（五）@三七会写作营
三七会萍海临风

      从隔离的初期，我们三人都不适应，彼此说话都还火药味十足。后随着时间的推移，到现在，我们仨人能够心平气和，幽默地对待彼此。看来，时间可真是个好东西，不仅能见证一个人的心性，还能看清自己的需求、他人的本质。今天晚上，孩子跑到厨房，告诉我她给人捐款了。我纳闷，不是给河南捐过款了么。当时，我还落后于她捐的呢。这次又捐给谁？看到我一脸狐疑，孩子说，还记得初四给她补课的那个男老师么？当让记得，当时，就因为是男
      

      • 

    • 教育微创新的意蕴
知北老师

      我是1992年参加工作的，一毕业就被分配到一所全县最偏僻落后的农村学校——付窝中学，12年后被调往一所已经连续十年全县倒数第一，也是很偏僻落后的农村学校——北宋镇第三中学。三年后到了北宋镇第一中学工作，这所学校教学质量也是连续几年落后了。2014年我到了北京市育英学校，这所学校是京城名校。2016年7月，我被育英学校派往原密云区第七中学工作，这是一所城乡接合部薄弱学校。学校现名为北京市育英学校密云
      

      • 

    • 我喝醉了，但是与你无关
Z先生的日记本

      2019年04月10号晚上我和一个朋友喝酒了，彻彻底底的喝醉了，喝到短片，事后我问L，我说我喝醉了之后，都发生了什么，L没有告诉我详情，但是跟我说了大致，他说我跟他一直聊天，说自己小的时候的事，说自己爸妈的事，说自己现在过得很苦可能，确实是喝醉了酒，才会毫无防备的跟其他人说这些吧。L还说感觉我过得很苦，很心疼。醉了酒之后还哭了，想想还真是丢人一年前，在宿舍也有一瓶红酒，那是舍友出去拉赞助时候，友商
      

      • 

    • android 自定义曲线图,Android自定义View——贝赛尔曲线
weixin_39767513
android自定义曲线图

      个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
      

      • 

    • Flink中的SQL Client和SQL Gateway
BigDataMLApplication
flinkflinksqlgateway

      Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
      

      • 

    • 2022年河南省高等职业教育技能大赛云计算赛项竞赛赛卷（样卷）
忘川_ydy
云计算云计算openstackkubernetesdockerpythonk8sansible

      #需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！第一部分：私有云任务1私有云服务搭建(10分)使用提供的用户名密码，登录竞赛用的云计算平台，按要求自行使用镜像创建两台云主机，创建完云主机后确保网络正常通信，然后按要求配置服务器。根据提供安装脚本框架，补充脚本完成OpenStack平台的安装搭
      

      • 

    • 浪潮 M5系列服务器IPMI无法监控存储RAID卡问题.
Songxwn
硬件服务器服务器运维

      简介浪潮的M5代服务器，可能有WebBMC无法查看存储RAID/SAS卡状态的情况，可以通过以下方式修改。修改完成后重启BMC即可生效。ESXiIPMITools使用：https://songxwn.com/ESXi8_IPMI/（Linux也可以直接使用）Linux/ESXiIPMITool下载：https://songxwn.com/file/ipmitoolWindows下载：https:/
      

      • 

    • 打印出1-100的奇数 。（C语言）
王多鱼001
C语言c语言算法数据结构

      代码：#includeintmain(){for(inti=1;i<101;i++){if(i%2==1){printf("%d,",i);}}return0;}
      

      • 

    • 【OpenModelica】4命令行大全
Wumbuk
python开发语言modelica

      命令行大全文章目录命令行大全一、SummaryofCommandsfortheInteractiveSessionHandler二、Runningthecompilerfromcommandline一、SummaryofCommandsfortheInteractiveSessionHandler以下是交互式会话处理器中当前可用命令的完整列表。•simulate(modelname)：翻译一个名为
      

      • 

    • 通俗易懂：MySQL中如何设置只读实例并确保数据一致性？
大龄下岗程序员
mysqljavamysqlspring

      在MySQL中设置只读实例主要应用于构建高可用性和扩展性的数据库环境，通常是为了分担读取负载或者用于备份和灾难恢复。以下是创建MySQL只读实例并确保数据一致性的基本步骤：1.创建并配置只读实例-主从复制设置-首先，你需要有一个主数据库实例（Master）负责接收所有的写操作。-创建一个或多个从数据库实例（Slave），并将它们配置为主数据库的复制品。这通常通过设置主从复制（Replication
      

      • 

    • 拼多多纸巾推荐：品质与性价比的完美结合
氧惠帮朋友一起省

      拼多多纸巾推荐拼多多纸巾返现怎么做在我们的日常生活中，纸巾已经成为不可或缺的用品。无论是在家庭、办公室还是旅途中，纸巾都是我们随时随地需要的物品。随着电商平台的兴起，越来越多的人选择在网上购买纸巾。其中，拼多多作为国内知名的电商平台之一，以其独特的社交电商模式和实惠的价格吸引了大量用户。今天，我们就来探讨如何在拼多多上选择品质优良、性价比高的纸巾，以及如何通过一些小技巧来获取更多的优惠。一、品质与
      

      • 

    • 5月8日盘前提示：维持短期可以操作到下周二左右的判断，重个股轻指数
九命_猫妖

      大盘：消息面。取消境外投资者额度限制，这个长线利好股市，短期影响不大，因为3000亿额度只用了1/3。额度本来就够用。走势看，昨天缩量横盘，走的还算中规中矩，近期一直弱势的次新股走势较强，前期强势股京威股份、光大嘉宝等跌停，由此判断市场还是存量博弈的市场，震荡是市场的主基调。维持短期可以操作到下周二左右的判断。下周后半段震荡回调的概率较高。思路：短期重个股轻指数行业和个股：物联网行业有利好，关注下
      

      • 

    • apache ftpserver-CentOS config
gengzg
apache

      <server xmlns="http://mina.apache.org/ftpserver/spring/v1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://mina.apache.o
      

      • 

    • 优化MySQL数据库性能的八种方法
AILIKES
sqlmysql

      1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
      

      • 

    • JeeSite 企业信息化快速开发平台
Kai_Ge
JeeSite

      JeeSite 企业信息化快速开发平台
平台简介
JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。
JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
      

      • 

    • 通过Spring Mail Api发送邮件
120153216
邮件main

      原文地址：http://www.open-open.com/lib/view/open1346857871615.html
使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】
Spring Mail API都在org.spri
      

      • 

    • Pysvn 程序员使用指南
2002wmj
SVN

      源文件:http://ju.outofmemory.cn/entry/35762
这是一篇关于pysvn模块的指南.
完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html.
pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个.
该
      

      • 

    • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL
357029540
SQL Server

      SELECT  R.session_id AS BlockedSessionID , 
        S.session_id AS BlockingSessionID , 
        Q1.text AS Block
      

      • 

    • Intent 常用的用法备忘
7454103
.netandroidGoogleBlogF#

      Intent
    应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。
下面列出几种Intent 的用法
显示网页:

      

      • 

    • Spring定时器时间配置
adminjun
spring时间配置定时器

      红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />
测试的时候，由于是每天定时执行，所以后面三个数
      

      • 

    • POJ 2421 Constructing Roads 最小生成树
aijuans
最小生成树

      来源：http://poj.org/problem?id=2421
题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。
思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。
代码：
#include <iostream>
#include <cstdio>
      

      • 

    • 重构笔记——提取方法（Extract Method）
ayaoxinchao
java重构提炼函数局部变量提取方法

      提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。
 
下面是我学习这个重构手法的笔记：
 
提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
      

      • 

    • 为UILabel添加点击事件
bewithme
UILabel

          默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。
 
UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
      

      • 

    • NoSQL数据库之Redis数据库管理(PHP-REDIS实例)
bijian1013
redis数据库NoSQL

      一.redis.php
<?php
//实例化
$redis = new Redis();
//连接服务器
$redis->connect("localhost");
//授权
$redis->auth("lamplijie");
//相关操
      

      • 

    • SecureCRT使用备注
bingyingao
secureCRT每页行数

      SecureCRT日志和卷屏行数设置
一、使用securecrt时，设置自动日志记录功能。
1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs；
2、点击Options -> Global Options -> Default Session -> Edite Default Sett
      

      • 

    • 【Scala九】Scala核心三：泛型
bit1129
scala

      泛型类
package spark.examples.scala.generics
class GenericClass[K, V](val k: K, val v: V) {
def print() {
println(k + "," + v)
}
}
object GenericClass {
def main(args: Arr
      

      • 

    • 素数与音乐
bookjovi
素数数学haskell

          由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。
    闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
      

      • 

    • Java-Collections Framework学习与总结-IdentityHashMap
BrokenDreams
Collections

              这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。
        简单的说，IdentityHashMap和HashM
      

      • 

    • 读《研磨设计模式》-代码笔记-享元模式-Flyweight
bylijinnan
java设计模式

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

      • 

    • PS人像润饰&调色教程集锦
cherishLC
PS

        1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓
http://www.howzhi.com/course/retouching/
  新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。
  所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
      

      • 

    • 更新多个字段的UPDATE语句
crabdave
update

      更新多个字段的UPDATE语句
 
                
update tableA a
set (a.v1, a.v2, a.v3, a.v4) = --使用括号确定更新的字段范围

      

      • 

    • hive实例讲解实现in和not in子句
daizj
hivenot inin

      本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html
当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。
假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
      

      • 

    • 一道24点的10+种非人类解法（2,3,10,10）
dsjt
算法

      这是人类算24点的方法？！！！
事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态
朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。
然后么。。。我就在深夜很得瑟的问室友求室友算
刚出完题，文哥的暴走之旅开始了
5秒后
      

      • 

    • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题
dcj3sjt126com
yiiframework

      在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
      

      • 

    • 对象与关系之间的矛盾：“阻抗失配”效应[转]
come_for_dream
对象

      概述
 
“阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。
 
“阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
      

      • 

    • 学习编程那点事
gcq511120594
编程互联网

      一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
      

      • 

    • Reverse Linked List II
hcx2013
list

      Reverse a linked list from position m to n. Do it in-place and in one-pass.
For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4,
return 
      

      • 

    • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介
jinnianshilongnian
spring 4.1

      目录
Spring4.1新特性——综述
Spring4.1新特性——Spring核心部分及其他
Spring4.1新特性——Spring缓存框架增强
Spring4.1新特性——异步调用和事件机制的异常处理
Spring4.1新特性——数据库集成测试脚本初始化
Spring4.1新特性——Spring MVC增强
Spring4.1新特性——页面自动化测试框架Spring MVC T
      

      • 

    • Hadoop集群工具distcp
liyonghui160com

       
 
1. 环境描述
两个集群：rock 和 stone
rock无kerberos权限认证，stone有要求认证。
1. 从rock复制到stone，采用hdfs
Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
      

      • 

    • 一个备份MySQL数据库的简单Shell脚本
pda158
mysql脚本

      　　主脚本（用于备份mysql数据库）： 　　该Shell脚本可以自动备份
数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。 　　
1. 分别建立目录“backup”和“oldbackup” 　　#mkdir /backup 　　#mkdir /oldbackup 　
      

      • 

    • 300个涵盖IT各方面的免费资源（中）——设计与编码篇
shoothao
IT资源图标库图片库色彩板字体

      
A. 免费的设计资源
Freebbble:来自于Dribbble的免费的高质量作品。
Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。
Graphic Burger:每个像素点都做得很细的绝佳的设计资源。
Pixel Buddha:免费和优质资源的专业社区。
Premium Pixels:为那些有创意的人提供免费的素材。

      

      • 

    • thrift总结 - 跨语言服务开发
uule
thrift

      官网
官网JAVA例子
thrift入门介绍
IBM-Apache Thrift - 可伸缩的跨语言服务开发框架
Thrift入门及Java实例演示
thrift的使用介绍
 
RPC 
 
POM：
<dependency>
<groupId>org.apache.thrift</groupId>

      

      •