sunny4handsome
sunny4handsome

springboot源码分析一

springboot是以spring为基础的，所以本文的大部分内容还是在分析spring，只不过是在spring boot的场景下分析。关于spring boot的自动化装配我们会在下一篇文章分析。本文分为三个部分，通过阅读spring boot源码和参阅了大量其他的文章，耗时两个礼拜，才总结出来。因为spring的源码篇幅巨大、设计思想很多，基本是java程序员必须掌握的技能，所以无论花费多大的时间精力去分析都是值得的。

  • 第一部分：基本概念：一些通用的东西
  • 第二部分：bean生命周期
  • 第三部分：源码分析
    本文源码分析基于springboot版本为2.1.3，对应的spring版本为5.1.5
    了解一二两个部分对spring的整个源码分析会有很大的帮助。至于源码分析部门还是建议大家自已去debug一遍。因为我的源码分析部分没有办法做到非常详尽。

Part 1 基本概念

1.1 必须知道的接口、类

1.1.1 Aware

  • 源码注释
A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
  • 翻译
    一个超级接口，指示一个bean可以被spring 容器通过回调的方式通知。
    比如要在Bean中获取它自已的BeanFactory, 那自定义的Bean实现BeanFactoryAware接口就可以了，BeanFactoryAware.setBeanFactory会在bean初始化之前被容器调用
public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}
  • 大白话
    使Bean可以具备获取容器资源的能力

1.1.2 BeanFactoryPostProcessor

  • 接口声明
@FunctionalInterface
public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
  • 源码注释
 Allows for custom modification of an application context's bean definitions, adapting the bean property values of the context's underlying bean factory.
  • 翻译
    BeanFactory的后置处理器。可以在Bean创建之前，BeanDefinition创建之后，去修改BeanDefinition（甚至可以修改Bean的属性值）。但是不建议直接修改bean的值，修改BeanDefinition的属性是可以的。为什么不建议在这里修改Bean的一些属性？如果要修改那么肯定需要获取bean，一旦执行获取操作，不存在就会创建bean。但是在这个阶段很多bean的PostProcessor还没有注册。那么（1）会导致bean的一些后置处理器不会执行（比如你自已定义的）（2）会导致bean的一些属性没有自动注入，因为自动注入（@autowire）也是通过bean的PostProcessor完成的。所以除非你确定你在做什么，所以不要在这里去执行获取bean操作。
  • 大白话
    任何Bean实现BeanFactoryPostProcessor接口，会被容器扫描到，postProcessBeanFactory会被调用。

1.1.3 BeanPostProcessor

  • 接口声明
public interface BeanPostProcessor {
 // Bean 初始化回调之前被调用
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
// Bean 初始化回调后被调用
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

何为Bean的初始化回调？InitializingBean的afterPropertiesSet 和自定义的init-method

  • 源码注释
Factory hook that allows for custom modification of new bean instances
  • 翻译
    Bean的后置处理器。可以修改bean实例。再强调一句，不要在BeanFactoryPostProcessor的实现里去获取bean和修改bean

1.1.4 BeanDefinition

  • 解释
    BeanDefinition是bean在spring中的描述(比如bean的有那些属性，值是什么，有那些注解等元信息)，有了BeanDefinition我们就可以创建Bean。注意BeanDefinition和Bean区别。特别是在我们和别人讨论或者看别人的分析的时候，要清楚我们在讨论的是BeanDefinition还是bean。BeanDefinition就相当于我们定义的类，bean就相当于我们实例的对象。

  • BeanDefinition具体的实现类如下


    image.png
  • BeanDefinition各个实现的具体应用场景
    BeanDefinition有很多的子实现，不同的子实现应用不同的场景。网上有很多的总结，但是我不知道是不是因为版本的问题，我debug出来的结果和他们的有些不同。比如说AnnotatedGenericBeanDefinition表示@Configuration注解注释的类，但是我debug出来的结果是只要是通过.class文件扫描出来的bean，哪怕是@Configuration注解的也是用的ScannedGenericBeanDefinition。所以大家注意区分，重点关注源码上面的注释部分（尽管很多注释的地方，读了也不知道说的什么，但有比没有好）
  1. RootBeanDefinition
    直接解读官方的注释
// 在运行时root bean表示一个merge bean（存在父子关系，所以需要合并，关于MergedBeanDefinition下面有解释）
 * A root bean definition represents the merged bean definition that backs
 * a specific bean in a Spring BeanFactory at runtime. 
//可以用来创建具有继承关系的bean
 * It might have been created
 * from multiple original bean definitions that inherit from each other,
 * typically registered as {@link GenericBeanDefinition GenericBeanDefinitions}.
// RootBeanDefinition在运行时是bean的一个统一的定义，那么本身不是用RootBeanDefinition 定义，也会创建一个新的RootBeanDefinition。AbstractBeanFactory 中就专门创建了一个对象mergedBeanDefinitions用来存放，并且和DefaultListableBeanFactory中beanDefinitionMap的大小相等。
 * A root bean definition is essentially the 'unified' bean definition view at runtime.
 *
// RootBeanDefinition可以用来创建自定义的BeanDefinition
 * 
Root bean definitions may also be used for registering individual bean definitions
 * in the configuration phase. However,
// 从Spring 2.5开始推荐使用GenericBeanDefinition，为什么我们下面讲
* since Spring 2.5, the preferred way to register
 * bean definitions programmatically is the {@link GenericBeanDefinition} class.
// GenericBeanDefinition 允许动态的定义父BeanDefinition（这里的动态不知道什么意思，在源码中没有发现在上面地方使用这个动态），不像RootBeanDefinition是硬编码的
 * GenericBeanDefinition has the advantage that it allows to dynamically define
 * parent dependencies, not 'hard-coding' the role as a root bean definition.
 *
  1. ChildBeanDefinition
    可以从父BeanDefinition继续属性，通过构造函数或者setParentName可以设置父BeanDefinition
  2. GenericBeanDefinition
    GenericBeanDefinition是官方推荐的BeanDefinition，因为GenericBeanDefinition一个类就可以替代RootBeanDefinition和ChildBeanDefinition的。主要是因为GenericBeanDefinition可以直接设置父BeanDefinition。个人感觉也没啥。我们看下源码中注解
/**
// 一站式商店，可以构造参数、属性值（MutablePropertyValues）
 * GenericBeanDefinition is a one-stop shop for standard bean definition purposes.
 * Like any bean definition, it allows for specifying a class plus optionally
 * constructor argument values and property values. Additionally, deriving from a
 * parent bean definition can be flexibly configured through the "parentName" property.
 *
// 用GenericBeanDefinition注册用户可见的bean definitions。用户可见的意思就是可以在后置处理器中获取
 * 
In general, use this {@code GenericBeanDefinition} class for the purpose of
 * registering user-visible bean definitions (which a post-processor might operate on,
 * potentially even reconfiguring the parent name). Use {@code RootBeanDefinition} /
 * {@code ChildBeanDefinition} where parent/child relationships happen to be pre-determined.
 *

总的来说，就是推荐使用GenericBeanDefinition

  1. ConfigurationClassBeanDefinition
    /**特指从configuration class中创建的bean definition
     * {@link RootBeanDefinition} marker subclass used to signify that a bean definition
     * was created from a configuration class as opposed to any other configuration source.
     * Used in bean overriding cases where it's necessary to determine whether the bean
     * definition was created externally.
     */

一般就是指用@Bean注解的bean

  1. AnnotatedGenericBeanDefinition
    springboot的启动类的bean表述是用该类定义的。类中有一个重要的属性AnnotationMetadata可以用来获取bean的所有的注解信息
  2. ScannedGenericBeanDefinition
    springboot是从启动来开始来扫描bean且是通过扫描.class文件的方式扫描的，所以除了启动类意外，所有的有@Component(包括@Configuaration, @service, @Controller)注解的bean都是包装成ScannedGenericBeanDefinition的, 但是@Bean注解的bean不是
  3. MergedBeanDefinition
    其实spring中并没有该类的具体定义，但是源码中又存在像getMergedBeanDefinition方法和MergedBeanDefinitionPostProcessor这个bean级别的后置处理器。其实在spring中MergedBeanDefinition对应的具体类是RootBeanDefinition。那么什么是MergedBeanDefinition？MergedBeanDefinition又是在springboot源码中什么时候处理的
  • 什么是MergedBeanDefinition
    MergedBeanDefinition表示将存在父子关系的bean的合并，也就是说你可以定义个一对存在继承关系的bean。spring会在某个时候将其合并（将父bean的属性拷贝一份到子bean）
  • MergedBeanDefinition的merge发生在那里
    在执行BeanDefinitionRegistryPostProcessor（发现bean，注册BeanDefinition）之前。springboot是通过如下代码去容器中查找BeanDefinitionRegistryPostProcessor后置处理器的
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false)

合并BeanDefinition就是在DefaultListableBeanFactory.getBeanNamesForType方法中

1.1.5 ConfigurationClassPostProcessor

用于处理启动配置类，@SpringBootApplication中存在@Configuration注解

{@link BeanFactoryPostProcessor} used for bootstrapping processing of
 {@link Configuration @Configuration} classes.

首先这是一个实现了BeanFactoryPostProcessor的后置处理器，而且还是实现了BeanDefinitionRegistryPostProcessor的后置处理器。spring的bean扫描、注册、自动配置等一切功能都由ConfigurationClassPostProcessor开始

1.2 Full 模式和Lite模式

此部分参考了 Spring的@Configuration配置类-Full和Lite模式，并结合了自已的源码分析

Full 模式和Lite模式是针对spring中的bean而言的，在ConfigurationClassUtils.checkConfigurationClassCandidate方法中有关于是Full 还Lite模式的判断

if (isFullConfigurationCandidate(metadata)) {       beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
        }
else if (isLiteConfigurationCandidate(metadata)) {      beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
        }

1.2.1 Full模式和Lite模式的定义

官方定义为：
类上有@Configuration注解的就是Full模式。
类上没有@Configuration注解，但是里面有@Bean方法就称为Lite模式。
透过源码再看这个定义是不完全正确的，而应该是有如下case均认为是Lite模式的配置类：

  1. 类上标注有@Component注解（包含@Service、@Controller）
  2. 类上标注有@ComponentScan注解
  3. 类上标注有@Import注解
  4. 类上标注有@ImportResource注解
  5. 若类上没有任何注解，但类内存在@Bean方法

以上case的前提均是类上没有被标注@Configuration，在Spring 5.2之后新增了一种case也算作Lite模式：标注有@Configuration(proxyBeanMethods = false)，注意：此值默认是true哦，需要显示改为false才算是Lite模式
细心的你会发现，自Spring5.2（对应Spring Boot 2.2.0）开始，内置的几乎所有的@Configuration配置类都被修改为了@Configuration(proxyBeanMethods = false)，目的何为？答：以此来降低启动时间，为Cloud Native继续做准备。

1.2.2 Full模式和Lite模式的不同

Full模式下：配置类会被CGLIB增强(生成代理对象)，放进IoC容器内的是代理
Lite模式下：放进IoC容器内的是类的实例，没有代理
代理的好处就是我们可以在方法的前后做一些其他的事情（AOP思想）

1.2.3 为什么需要Full模式和Lite模式

假设已经存在Persion类，请思考下面两段代码中的persion1和persion2是不是相等的（是不是同一个对象）

@Configuration
public class MainConfiguration{
    @Bean("persion1")
    public Persion persion1() {
        return new Persion("payne");
    }
    @Bean("persion2")
    public Persion persion2() {
        return persion1();
    }
}

@Component
public class MainConfiguration{
    @Bean("persion1")
    public Persion persion1() {
        return new Persion("payne");
    }
    @Bean("persion2")
    public Persion persion2() {
        return persion1();
    }
}

在Full模型下，也就是代码片段一。persion1和persion2是相等的，尽管在persion2()方法中调用了persion1()方法。persion1()中每次是new 一个Persion的
在Lite模式下，也就是代码片段二，persion1和persion2是不相等的。
如果没有代理对象，我们是做不到代码一中的效果的。

Part 2 Bean生命周期

spring bean 的生命周期在BeanFactory接口注释中有完整的描述。分为两个部分，第一部分是bean可使用之前的部分，第二部分为shutdown bean factory之后的

// 第一部分
* 
Bean factory implementations should support the standard bean lifecycle interfaces
 * as far as possible. The full set of initialization methods and their standard order is:
 * 
    
 * 
  1. BeanNameAware's {@code setBeanName}
 * 
  2. BeanClassLoaderAware's {@code setBeanClassLoader}
 * 
  3. BeanFactoryAware's {@code setBeanFactory}
 * 
  4. EnvironmentAware's {@code setEnvironment}
 * 
  5. EmbeddedValueResolverAware's {@code setEmbeddedValueResolver}
 * 
  6. ResourceLoaderAware's {@code setResourceLoader}
 * (only applicable when running in an application context)
 * 
  7. ApplicationEventPublisherAware's {@code setApplicationEventPublisher}
 * (only applicable when running in an application context)
 * 
  8. MessageSourceAware's {@code setMessageSource}
 * (only applicable when running in an application context)
 * 
  9. ApplicationContextAware's {@code setApplicationContext}
 * (only applicable when running in an application context)
 * 
  10. ServletContextAware's {@code setServletContext}
 * (only applicable when running in a web application context)
 * 
  11. {@code postProcessBeforeInitialization} methods of BeanPostProcessors
 * 
  12. InitializingBean's {@code afterPropertiesSet}
 * 
  13. a custom init-method definition
 * 
  14. {@code postProcessAfterInitialization} methods of BeanPostProcessors
 * 

 *
//第二部分
 * 
On shutdown of a bean factory, the following lifecycle methods apply:
 * 
    
 * 
  1. {@code postProcessBeforeDestruction} methods of DestructionAwareBeanPostProcessors
 * 
  2. DisposableBean's {@code destroy}
 * 
  3. a custom destroy-method definition
 *

整理如下：
第一部分

  1. BeanNameAware.setBeanName
  2. BeanClassLoaderAware.setBeanClassLoader
  3. BeanFactoryAware.setBeanFactory
  4. EnvironmentAware.setEnvironment
  5. EmbeddedValueResolverAware.setEmbeddedValueResolver
  6. ResourceLoaderAware.setResourceLoader
  7. ApplicationEventPublisherAware.setApplicationEventPublisher
  8. MessageSourceAware.setMessageSource
  9. ApplicationContextAware.setApplicationContext
  10. ServletContextAware.setServletContext
  11. BeanPostProcessors.postProcessBeforeInitialization
  12. InitializingBean.afterPropertiesSet
  13. a custom init-method definition
  14. BeanPostProcessors.postProcessAfterInitialization
    以上生命周期是按发生的顺序排序的，最早的生命周期BeanNameAware.setBeanName也是发生在bean实例化、填充属性之后的，此时的bean已经是一个完整的对象了，已经是可用状态。
    借用参考文献一的图如下：
    image.png

第二部分

  1. DestructionAwareBeanPostProcessors.postProcessBeforeDestruction
  2. DisposableBean.destroy
  3. a custom destroy-method definition

bean更完整的生命周期

但是以上的上面周期仅仅是我们自已定义的bean能看到的生命周期，那spring 本身一些bean的生命周期是没有包含在这里面的。很久之前写过一篇通过xml注册bean的生命周期文章中总结过一个完整的图，在这里同样适用，因为spring的bean生命周期是一样的。大家也可以再看一下这篇文章前面总结的一些概念spring bean 生命周期。我们再把图搬过来一下

完整的bean生命周期

这个图第一行BeanDefinitionRegistryPostProcessor的实例化就是指的我们在1.1.5节提到的ConfigurationClassPostProcessor。重要的事情多提几遍ConfigurationClassPostProcessor是spring boot中IOC的起点。

Part 3 源码分析

源码分析部分，我会在我认为重要的地方写上注释，也会去掉一些我任认为不重要的地方。
目录的编号对应注释前面的编号
springboot的代码篇幅比较大。我们暂且分为三个大的部分

    1. 启动初始化部分
    1. bean扫描部分
    1. bean的实例化部分

启动初始化部分

3.1、SpringApplication.run方法

public ConfigurableApplicationContext run(String... args) {
        ConfigurableApplicationContext context = null;
        Collection exceptionReporters = new ArrayList<>();
        configureHeadlessProperty();
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
//（1）添加一些基本的类型转换器（2）配置环境（1、配置文件，2、激活了那个profile（3）占位符等（@value注解的占位符）)
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            configureIgnoreBeanInfo(environment);
//打印springboot的banner
            Banner printedBanner = printBanner(environment);
//创建ApplicationContent, (1)DefaultListableBeanFactory也在这里创建 (2) 这里有一个非常重要的BeanFactoryPostProcessor：ConfigurationClassPostProcessor在这里面注册
            context = createApplicationContext();
            exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
//(3)加载primarySources（其实就是我们的启动类），将其注册为一个bean(bean的注册指创建一个BeanDefinition，然后放到beanDefinitionMap对象中，并没有完成实例化)
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
//（4） 最复杂，关键的地方，下面详细讲解
            refreshContext(context);
// （5）当ApplicationContent refresh 后，执行该方法，这里是一个空的实现
            afterRefresh(context, applicationArguments);
            stopWatch.stop();
            listeners.started(context);
            callRunners(context, applicationArguments);
            listeners.running(context);
        return context;
    }

3.1.4 springApplication.refreshContext详解

springApplication.refreshContext方法实际调用的是AbstractApplicationContext.refresh()方法。下面直接看该方法

public void refresh() throws BeansException, IllegalStateException {

            // （1）无重要内容，主要设置启动时间，激活标志
            prepareRefresh();

            // （2）无重要内容，获取bean factory（实际类型为DefaultListableBeanFactory在上面已经创建过了）
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // （3）添加了两个重要的BeanPostProcessor，（1）ApplicationContextAwareProcessor，bean生命周期关于Aware部分的就是通过添加该bean post processor 实现 （2）ApplicationListenerDetector，关于事件监听（发布-订阅者模式）是通过该bean post processor 实现的(3)添加了3个bean（environment， systemProperties，systemEnvironment）看名字就知道是关于系统一些变量的
            prepareBeanFactory(beanFactory);

                // （4）无具体实现，其他content可以重写改方法
                postProcessBeanFactory(beanFactory);

                // （5）调用一些已经注册为bean的BeanFactoryPostProcessor，还记的创建content时候我们提到的那个 重要的ConfigurationClassPostProcessor类吗？
                invokeBeanFactoryPostProcessors(beanFactory);

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

                //（7）国际化相关处理

                initMessageSource();

                //（8） 事件通知机制，发布订阅者实现
                initApplicationEventMulticaster();

                // （9）其他的上下文比如web应用等可以实现改方法，用来实例化一些特殊的bean
                onRefresh();

                // （10）事件通知机制，注册事件
                registerListeners();

                // （11）我们在invokeBeanFactoryPostProcessors中扫描到了很对的bean，我们执行将其BeanDefinition注册到容器中，但是还没有实例化，那么实例化就在finishBeanFactoryInitialization中实例化。包括BeanPostProcessor的执行
                finishBeanFactoryInitialization(beanFactory);

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

3.2 bean的扫描部分

3.2.1 invokeBeanFactoryPostProcessors

    /**
     * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
     * respecting explicit order if given.
     * 
Must be called before singleton instantiation.
     */

该方法的注释写的很明白，实例化并且调用注册为bean的BeanFactoryPostProcessor，这里面会调用我们在createApplicationContext方法中注册为bean的ConfigurationClassPostProcessor对象，该对象是是一个BeanFactoryPostProcessor。试想一下spring boot是如何找到我们定义的bean的呢？其他就是通过ConfigurationClassPostProcessor

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

        // 后置处理器已经执行过的bean，防止执行多次
        Set processedBeans = new HashSet<>();
// 将后置处理器分类，具体的见代码下面的解释
        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;
//(1) 执行invokeBeanDefinitionRegistryPostProcessors                  registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                }
                else {
                    regularPostProcessors.add(postProcessor);
                }
            }

// 见下面解释
            List currentRegistryProcessors = new ArrayList<>();

            // 获取BeanDefinitionRegistryPostProcessor的bean名称，实际上注册为bean且类型是BeanDefinitionRegistryPostProcessor的类就是ConfigurationClassPostProcessor，且只有这一个
            String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
// ConfigurationClassPostProcessor是实现了PriorityOrdered接口的
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//beanFactory.getBean 当bean没有实例化的时候，会实例化，所以ConfigurationClassPostProcessor之前只是一个BeanDefinition,在这里会实例化
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
// （1）这里才是正式的ConfigurationClassPostProcessor， 会将所有满足bean条件的BeanDefinition注册 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();

            // 获取BeanDefinitionRegistryPostProcessors 类型的bean 并且实现 Ordered接口
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                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);
// （1）再次执行BeanFactoryPostProcessors, 注意如果上面已经执行过了，则不再执行         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();

            // 在执行上面后置处理器的过程中，会扫描到一些新的后置处理器，那么也要执行
            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);
//(1) 执行invokeBeanDefinitionRegistryPostProcessors                  invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                currentRegistryProcessors.clear();
            }

            // （2）之前注册过一个重要的BeanFactoryPostProcessor: ConfigurationClassPostProcessor在这里会被调用，如果Bean是Full 模式的，那么cglib生成代理类放到beanDefinitionMap中

            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        }

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

        // 在扫描的过程中会发现新的实现BeanFactoryPostProcessor的bean，不如我们自已实现的一些后置处理器
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // 实现 PriorityOrdered的后置处理器先执行
        // 实现Ordered的后置处理其次, 最后是其他的后置处理器
        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.
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
//（2）执行invokeBeanFactoryPostProcessors
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
        List orderedPostProcessors = new ArrayList<>();
        for (String postProcessorName : orderedPostProcessorNames) {
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        sortPostProcessors(orderedPostProcessors, beanFactory);
//（2）执行invokeBeanFactoryPostProcessors      
        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

        // Finally, invoke all other BeanFactoryPostProcessors.
        List nonOrderedPostProcessors = new ArrayList<>();
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
//（2）执行invokeBeanFactoryPostProcessors
        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();
    }

总结

（1）方法中有三个主要的对象：

  1. regularPostProcessors：普通的后置处理器，只实现BeanFactoryPostProcessor接口
  2. registryProcessors：除了实现BeanFactoryPostProcessor还实现BeanDefinitionRegistryPostProcessor的后置处理器
  3. currentRegistryProcessors：在容器中注册为bean且类型是BeanDefinitionRegistryPostProcessor的后置处理器（注意并发所有的后置处理器都会注册为bean），这里只有ConfigurationClassPostProcessor是满足条件的

上面对象中的后置处理器都执行完了，才会执行我们自已定义的后置处理器和我们再扫描过程中发现的后置处理器，我们经常使用@value("${变量名称}")来填充属性值就是通过在这里扫描到的PropertySourcesPlaceholderConfigurer这个后置处理器实现的

（2）执行顺序

  1. currentRegistryProcessors中实现PriorityOrdered的后置处理器最先执行
  2. currentRegistryProcessors中实现Ordered的后置处理器其次
  3. registryProcessors中的后置处理器
  4. regularPostProcessors中的后置处理器最后
  5. 我们自已在代码注册的后置处理器（就是通过ConfigurationClassPostProcessor才让容器发现我们自已定义的后置处理器的，所以肯定是最后执行）

两条原则

1. 先执行实现BeanDefinitionRegistryPostProcessor的后置处理器，后执行实现BeanFactoryPostProcessor的限制性（注意执行的方法不一样）

2. 实现PriorityOrdered的后置处理器先执行，实现Ordered的后执行

结合代码来说就是BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry先执行，BeanFactoryPostProcessor.postProcessBeanFactory后执行。BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor实现类，所以ConfigurationClassPostProcessor先执行postProcessBeanDefinitionRegistry来注册BeanDefinition，然后执行postProcessBeanFactory将Full模式的bean class用cglib生成代理类放到beanDefinitionMap中

3.2.1.1 invokeBeanDefinitionRegistryPostProcessors

    private static void invokeBeanDefinitionRegistryPostProcessors(
            Collection postProcessors, BeanDefinitionRegistry registry) {

        for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
// 调用ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry  
        postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
    }

postProcessBeanDefinitionRegistry实际处理逻辑在processConfigBeanDefinitions中
ConfigurationClassPostProcessor.processConfigBeanDefinitions处理逻辑

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        List configCandidates = new ArrayList<>();
// 获取当前content所有的BeanDefinition（没有实例化的bean）
        String[] candidateNames = registry.getBeanDefinitionNames();

        for (String beanName : candidateNames) {
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//(1)关于Full模式和life模式参见文章末尾，这里主要是找出声明了注解@Configuration或者@Component的类（注意像@Service，@Controller等存在嵌套的元注解@Component也是满足这里的条件的）
            if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
                    ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
                }
            }
// (2) 判断该类有没有可能是configuration 类
            else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
                configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
            }
        }

// 由于springboot的启动类上是有@SpringBootApplication注解的，该注解是存在@Configuration嵌套注解的，所以启动类肯定是满足这个条件的configCandidates里面最起码是存在启动类的这个对象的
        if (configCandidates.isEmpty()) {
            return;
        }
// 创建一个@Configuration class解析类
        // Parse each @Configuration class
        ConfigurationClassParser parser = new ConfigurationClassParser(
                this.metadataReaderFactory, this.problemReporter, this.environment,
                this.resourceLoader, this.componentScanBeanNameGenerator, registry);

        Set candidates = new LinkedHashSet<>(configCandidates);
        Set alreadyParsed = new HashSet<>(configCandidates.size());
//(4)注意这里是一个循环，正常情况下，这里的candidates里面只有一个springboot启动类，所以该循环的作用就是如果在扫描启动类的过程又碰到新的@Configuration class那么一直扫描下去，知道找出所有的@Configuration class，扫描完了其实Bean也就扫描完了
        do {
            parser.parse(candidates);
            parser.validate();

            Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
            configClasses.removeAll(alreadyParsed);

            // Read the model and create bean definitions based on its content
            if (this.reader == null) {
                this.reader = new ConfigurationClassBeanDefinitionReader(
                        registry, this.sourceExtractor, this.resourceLoader, this.environment,
                        this.importBeanNameGenerator, parser.getImportRegistry());
            }
//(5)Configuration class 中的@Bean 方法还没有注册BeanDefinition, 下面会注册(扫描@Import注解时，也会出现新的Configuration class（自动配置）)
            this.reader.loadBeanDefinitions(configClasses);
            alreadyParsed.addAll(configClasses);

            candidates.clear();
// 在扫描到的Configuration class中也是有@Component注解的，那么循环的扫描
            if (registry.getBeanDefinitionCount() > candidateNames.length) {
                String[] newCandidateNames = registry.getBeanDefinitionNames();
                Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
                Set alreadyParsedClasses = new HashSet<>();
                for (ConfigurationClass configurationClass : alreadyParsed) {
                    alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
                }
                for (String candidateName : newCandidateNames) {
                    if (!oldCandidateNames.contains(candidateName)) {
                        BeanDefinition bd = registry.getBeanDefinition(candidateName);
                        if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                                !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                            candidates.add(new BeanDefinitionHolder(bd, candidateName));
                        }
                    }
                }
                candidateNames = newCandidateNames;
            }
        }
        while (!candidates.isEmpty());

        // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
        if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
            sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
        }

        if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
            // Clear cache in externally provided MetadataReaderFactory; this is a no-op
            // for a shared cache since it'll be cleared by the ApplicationContext.
            ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
        }
    }

parse的调用链比较长，跳过无关的方法，扫描的核心逻辑在下面的方法中

3.2.1.1.4 ConfigurationClassParser.doProcessConfigurationClass
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
            throws IOException {
//如果该ConfigurationClass存在成员内部类，那么递归的扫描该类
        if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            // Recursively process any member (nested) classes first
            processMemberClasses(configClass, sourceClass);
        }

        // 处理@PropertySource注解
        for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
                sourceClass.getMetadata(), PropertySources.class,
                org.springframework.context.annotation.PropertySource.class)) {
            if (this.environment instanceof ConfigurableEnvironment) {
                processPropertySource(propertySource);
            }
            else {
                logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                        "]. Reason: Environment must implement ConfigurableEnvironment");
            }
        }

        // 处理@ComponentScan 注解，ComponentScan会扫描我们启动类所在包下面所有的class文件，将所有有@Component注解的class会封装成BeanDefinition注册到容器中
        Set componentScans = AnnotationConfigUtils.attributesForRepeatable(
                sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
        if (!componentScans.isEmpty() &&
                !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
            for (AnnotationAttributes componentScan : componentScans) {
                // The config class is annotated with @ComponentScan -> perform the scan immediately
                Set scannedBeanDefinitions =
                        this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                // 递归的扫描上面扫描到的scannedBeanDefinitions，如果该class上还有@PropertySource，@ComponentScan等注解就一直递归的处理
                for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }

        // 处理@Import 注解, @SpringBootApplication的复合注解@EnableAutoConfiguration中存在@Import(AutoConfigurationImportSelector.class)，springboot中的自动配置就是在这里通过这个注解实现的
        processImports(configClass, sourceClass, getImports(sourceClass), true);

        // 处理 @ImportResource 注解
        AnnotationAttributes importResource =
                AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
        if (importResource != null) {
            String[] resources = importResource.getStringArray("locations");
            Class readerClass = importResource.getClass("reader");
            for (String resource : resources) {
                String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
                configClass.addImportedResource(resolvedResource, readerClass);
            }
        }

        // 处理 @Bean注解的 方法
        Set beanMethods = retrieveBeanMethodMetadata(sourceClass);
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }

        // 处理接口的默认方法
        processInterfaces(configClass, sourceClass);

        // 处理父类 superclass
        if (sourceClass.getMetadata().hasSuperClass()) {
            String superclass = sourceClass.getMetadata().getSuperClassName();
            if (superclass != null && !superclass.startsWith("java") &&
                    !this.knownSuperclasses.containsKey(superclass)) {
                this.knownSuperclasses.put(superclass, configClass);
                // Superclass found, return its annotation metadata and recurse
                return sourceClass.getSuperClass();
            }
        }

        // No superclass -> processing is complete
        return null;
    }

总结一下，方法的参数ConfigurationClass就是我们的启动的封装类，所以扫描就是从我们的启动类开始扫描的
（1） 方法作用
递归的扫描满足条件的Bean将其封装成BeanDefinition注册到容器上下文中。递归是从ConfigurationClass开始的，那么ConfigurationClass是如何定义的呢？通过如下方法判断。

ConfigurationClassUtils.checkConfigurationClassCandidate(BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory)

总结一下就是：如果类上面有@Component注解就是ConfigurationClassCandidate，因为@Configuration,@Service,@Controller等注解的元注解也是包含@Component的所以有这些注解的类也是ConfigurationClassCandidate。特别，如果类上没有注解但是，存在@Bean方法注解，那么该类也是ConfigurationClassCandidate

（2）扫描循序
扫描过程中只要碰到ConfigurationClassCandidate就递归扫描，碰到bean就将其BeanDefinition注册到容器中

  1. 成员内部类
  2. @PropertySource注解
  3. @ComponentScan注解
  4. @Import注解
  5. @ImportResource注解
  6. 内部@Bean方法
  7. 接口默认方法
  8. 父类

3.3 bean的注册部分

bean的注册主要实现在refresh方法的finishBeanFactoryInitialization

finishBeanFactoryInitialization详解

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // 设置冻结BeanDefinition的flag，不希望在注册实例的时候改变bean的定义了
        beanFactory.freezeConfiguration();
      // （1）实例化剩下的非lazy的bean，有些bean比如自已定义的BeanPostProcessor还有容器的一些bean在之前已经实例化过了，所以这里实现剩下的，我们自已代码中很多就是这里实例化
        // Instantiate all remaining (non-lazy-init) singletons.
        beanFactory.preInstantiateSingletons();

3.3.1 preInstantiateSingletons

    public void preInstantiateSingletons() throws BeansException {
// beanDefinitionNames 存放所有的之前扫描到的BeanDefinition
        List beanNames = new ArrayList<>(this.beanDefinitionNames);
// 遍历所有的BeanDefinition，创建bean
        for (String beanName : beanNames) {
// MergedBeanDefinition 之前已经详细说过概念，合并具有继承关系的BeanDefinition
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 工程bean的处理
                if (isFactoryBean(beanName)) {
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        final FactoryBean factory = (FactoryBean) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                                            ((SmartFactoryBean) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
// (1)获取bean，获取不到则创建
                    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((PrivilegedAction) () -> {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }
 
 
3.3.1.1 doCreateBean
 
 
跳过不重要的调用关系直接看doCreateBean
 
 
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
// 创建bean实例
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
//填充bean属性，@autowire字段的属性就是在这里填充的，通过AutowiredAnnotationBeanPostProcessor这个后置处理器
            populateBean(beanName, mbd, instanceWrapper);
// （1）初始化回调
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {  
        }
        }

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

        return exposedObject;
    }

 
 
3.3.1.1.1 initializeBean
 
 
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
// bean生命周期与Aware相关的在这里调用       
        invokeAwareMethods(beanName, bean);
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
// 初始化回调前置操作
            wrappedBean = 
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
// 初始化回调
        invokeInitMethods(beanName, wrappedBean, mbd);
// 初始化回调后置操作
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = 
applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }

 
 
参考文献
 
 
     
  
  1. Spring – Bean Life Cycle
    2.  
  
  2. Spring源码分析之BeanFactoryPostProcessor调用过程详解
    3.  
  
  3. Spring的@Configuration配置类-Full和Lite模式
    4.  
  
  4. 深入理解SpringBoot的过滤条件--AutoConfigure
    5.  
  
  5. EnableAutoConfiguration注解的工作原理
    6.  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(springboot源码分析一)

        

            

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

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

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

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

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

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

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

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

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

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

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

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

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

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

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

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

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • 《策划经理回忆录之二》
                        路基雅虎

                        
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                                
  • 对股票分析时要注意哪些主要因素？
                                    会飞的奇葩猪
股票 分析 云掌股吧
                                    
     
　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。 
 
    一、成交量 
 
　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
    
                                
    • 
                                
  • 【Scala十八】视图界定与上下文界定
                                    bit1129
scala
                                    
    Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。 
  
隐式参数 
首先引入一个泛型函数max，用于取a和b的最大值 
  def max[T](a: T, b: T) = {
    if (a > b) a else b
  } 
 因为T是未知类型，只有运行时才会代入真正的类型，因此调用a > 
    
                                
    • 
                                
  • C语言的分支——Object-C程序设计阅读有感
                                    darkblue086
applec框架cocoa
                                    
    自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 
Object-C程序设计这本书
    
                                
    • 
                                
  • 去除浏览器对表单值的记忆
                                    周凡杨
html记忆autocompleteform浏览
                                    
      
                                   &n
    
                                
    • 
                                
  • java的树形通讯录
                                    g21121
java
                                    
    最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 
	// 首先取出每个部门的联系人
			for (int i = 0; i < depList.size(); i++) {
				List<Contacts> list = getContactList(depList.get(i
    
                                
    • 
                                
  • Nginx安装部署
                                    510888780
nginxlinux
                                    
    Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
    
                                
    • 
                                
  • java servelet异步处理请求
                                    墙头上一根草
ｊａｖａ异步返回ｓｅｒｖｌｅｔ
                                    
    servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能， 
   
  
  final AsyncContext ac = request.startAsync(request, response); 
  ac.s
    
                                
    • 
                                
  • 我的spring学习笔记8-Spring中Bean的实例化
                                    aijuans
Spring 3
                                    
    在Spring中要实例化一个Bean有几种方法： 
 
1、最常用的（普通方法） 
 
 
<bean id="myBean" class="www.6e6.org.MyBean" /> 
 
使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。 
 
（有构造方法的下个文细说） 
 
2、还
    
                                
    • 
                                
  • 为Mysql创建最优的索引
                                    annan211
mysql索引
                                    
    


	索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。
	索引经常会被误解甚至忽略，而且经常被糟糕的设计。
	索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比
	较好的索引性能要好2个数量级。
	
	1 索引的类型
	  (1) B-Tree
	    不出意外，这里提到的索引都是指 B-
    
                                
    • 
                                
  • 日期函数
                                    百合不是茶
oraclesql日期函数查询
                                    
      
ORACLE日期时间函数大全

   TO_DATE格式(以时间:2007-11-02   13:45:25为例)
   
        Year:      
        yy two digits 两位年                显示值:07
        yyy three digits 三位年                显示值:007
   
    
                                
    • 
                                
  • 线程优先级
                                    bijian1013
javathread多线程java多线程
                                    
    多线程运行时需要定义线程运行的先后顺序。 
线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。 
实例： 
package com.bijian.study;

/**
 * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法
 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
    
                                
    • 
                                
  • 适配器模式和代理模式的区别
                                    bijian1013
java设计模式
                                    
    一.简介        适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。      &nbs
    
                                
    • 
                                
  • 【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件
                                    bit1129
Mybatis3
                                    
     SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句， 
这些元素包含三方面内容 
1. 要执行的SQL语句 
2. SQL语句的入参，比如查询条件 
3. SQL语句的返回结果
    
                                
    • 
                                
  • oracle大数据表复制备份个人经验
                                    bitcarter
oracle大表备份大表数据复制
                                    
    前提： 
   数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。 
    
    
                                
    • 
                                
  • HTTP加速器varnish安装小记
                                    ronin47
http varnish 加速
                                    
    上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！ 
苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ 
Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
    
                                
    • 
                                
  • java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度
                                    bylijinnan
java
                                    
    

public class LongestSymmtricalLength {

	/*
	 * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。
	 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。
	 */
	
	public static void main(String[] args) {
		Str
    
                                
    • 
                                
  • 学习编程的一点感想
                                    Cb123456
编程感想Gis
                                    
           写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目. 
  
   本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
    
                                
    • 
                                
  • [能源与安全]美国与中国
                                    comsci
能源
                                    
     
 
     现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。 
 
 
      在这个大
    
                                
    • 
                                
  • SEMI-JOIN执行计划突然变成HASH JOIN了 的原因分析
                                    cwqcwqmax9
oracle
                                    
    甲说： 
A B两个表总数据量都很大，在百万以上。 
idx1  idx2字段表示是索引字段 
A B 两表上都有 
col1字段表示普通字段 
 
select xxx from A 
where A.idx1 between mmm and nnn 
     and exists (select 1 from B where B.idx2 =
    
                                
    • 
                                
  • SpringMVC-ajax返回值乱码解决方案
                                    dashuaifu
AjaxspringMVCresponse中文乱码
                                    
      
SpringMVC-ajax返回值乱码解决方案 
  
一：（自己总结，测试过可行） 
ajax返回如果含有中文汉字，则使用：（如下例：） 
@RequestMapping(value="/xxx.do")       public @ResponseBody void getPunishReasonB
    
                                
    • 
                                
  • Linux系统中查看日志的常用命令
                                    dcj3sjt126com
OS
                                    
    因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 
cat 
tail -f 
日 志 文 件 说 明 
/var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 
/var/log/secure 与安全相关的日志信息 
/var/log/maillog 与邮件相关的日志信
    
                                
    • 
                                
  • [应用结构]应用
                                    dcj3sjt126com
PHPyii2
                                    
    应用主体 
应用主体是管理 Yii 应用系统整体结构和生命周期的对象。 每个Yii应用系统只能包含一个应用主体，应用主体在 入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。 
 
 补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
    
                                
    • 
                                
  • assertThat用法
                                    eksliang
JUnitassertThat
                                    
    junit4.0  assertThat用法 
一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 
注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 
2、assertThat( testedNumber, anyOf( g
    
                                
    • 
                                
  • android点滴2
                                    gundumw100
应用服务器android网络应用OSHTC
                                    
    如何让Drawable绕着中心旋转？ 
 

Animation a = new RotateAnimation(0.0f, 360.0f,
Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f);
a.setRepeatCount(-1);
a.setDuration(1000);
 
 
如何控制Andro
    
                                
    • 
                                
  • 超简洁的CSS下拉菜单
                                    ini
htmlWeb工作html5css
                                    
    效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>简洁的HTML+CSS下拉菜单-HoverTree</title>
    
                                
    • 
                                
  • kafka consumer防止数据丢失
                                    kane_xie
kafkaoffset commit
                                    
    kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。 
  
尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。 
  
考虑这样一个case，partiton_num=2
    
                                
    • 
                                
  • @Repository、@Service、@Controller 和 @Component
                                    mhtbbx
DAOspringbeanprototype
                                    
    @Repository、@Service、@Controller 和 @Component 将类标识为Bean 
Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
    
                                
    • 
                                
  • java 多线程高并发读写控制 误区
                                    qifeifei
java thread
                                    
    先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ 
public class testTh7 {
	private String data;
	public String read(){
		System.out.println(Thread.currentThread().getName() + "read data " 
    
                                
    • 
                                
  • mongodb replica set(副本集)设置步骤
                                    tcrct
javamongodb
                                    
    网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下： 
 
首先先去下载一个mongodb最新版，目前最新版应该是2.6 
 

cd /usr/local/bin
wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz
tar -zxvf  mongodb-linux-x86_64-2.6.0.t
    
                                
    • 
                                
  • rust学习笔记
                                    wudixiaotie
学习笔记
                                    
    1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 
let x = 1; let mut y = 2; 
2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 
3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 
4.每个语句结尾都要加分
    
                                
    •