前言

本文是笔者所著的 Spring Core Container 源码分析系列之一；

本篇文章主要试图梳理出 Spring Beans 的初始化主流程和相关核心代码逻辑；

本文转载自本人的私人博客，伤神的博客： http://www.shangyang.me/2017/04/01/spring-core-container-sourcecode-analysis-beans-instantiating-process/

本文为作者的原创作品，转载需注明出处；

源码分析环境搭建

参考 Spring Core Container 源码分析二：环境准备

测试用例

依然使用这个官网上的用例，来进行调试；

Person.java

    package org.shangyang.spring.container;

    /**
     - 
     - @author shangyang
     *
     */
    public class Person {

        String name;

        Person spouse;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Person getSpouse() {
            return spouse;
        }

        public void setSpouse(Person spouse) {
            this.spouse = spouse;
        }

    }

beans.xml



    
    
        
        
    

    
        
            
   
@Test
public void testApplicationContext(){

  @SuppressWarnings("resource")
  ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

  Person p = context.getBean("john", Person.class);

  assertEquals("John Doe", p.getName() );

  assertEquals("Jane Doe", p.getSpouse().getName() );

}

源码分析

备注，这里只针对 Spring 容器实例化 singleton bean 的主流程进行介绍；singleton bean 在 Spring 容器中被初始化的特点是，在 Spring 容器的启动过程中就进行初始化；

（最好的分析源码的方式，就是通过高屋建瓴，逐个击破的方式；首先通过流程图获得它的蓝图(顶层设计图)，然后再根据蓝图上的点逐个击破；最后才能达到融会贯通，胸有成竹的境界；所以，这里作者用这样的方式带你深入剖析 Spring 容器里面的核心点，以及相关主流程到底是如何运作的。）

主流程

Spring Core Container 源码分析三：Spring Beans 初始化流程分析_第1张图片

本章节我们将详细去阐述的是，Spring 容器是如何对 Singleton bean 进行初始化并注册到当前容器的；与之相关的主要有两个流程，

  1. 解析 bean definitions 并注册
    解析 bean definitiions 并注册到当前的 BeanFactory 中；此步骤是在 step 1.1.1.2 obtainFreshBeanFactory 完成；更详细的介绍参考解析并注册 bean definitions 流程

  2. 从 #1 中找到所有的已注册的 singleton bean definitions，遍历，实例化得到 Singleton beans；此步骤对应的是 step 1.1.1.11 finishBeanFactoryInitialization 开始进行 singleton bean 的构造过程，其后调用AbstractBeanFactory#getBean(beanFactory)方法进行构造；更详细的介绍参考 Do Get Bean 流程。

解析并注册 bean definitions 流程

该部分参考新的博文 Spring Core Container 源码分析七：注册 Bean Definitions

Do Get Bean 流程

Do Get Bean 流程的入口是 AbstractBeanFactory#doGetBean 方法，主流程图如下，

Spring Core Container 源码分析三：Spring Beans 初始化流程分析_第2张图片

主流程大致为，从缓存中找到是否已经实例化了该 singleton bean，如果已经实例化好了，那么就直接返回；如果在缓存中没有找到，则将当前的 bean 封装为 RootBeanDefinition，然后通过调用 DefaultSingletonBeanRegistry#getSingleton 得到初始化好的 singleton bean，然后将其注册至缓存( step 1.3.3 addSingleton )，然后再判断是普通 bean 还是 factory bean 作必要的处理( step 1.4 getObjectForBeanInstance )后，最后返回；

RootBeanDefinition

初始化了一个 RootBeanDefinition 对象，正如其类名描述的那样，是该 bean 的顶层描述；包含了 bean 的字段属性，ref属性以及继承相关等等属性；

Step 1.3：DefaultSingletonBeanRegistry#getSingleton

此步骤的相关代码如下，

// Create bean instance.
if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, new ObjectFactory() {
        @Override
        public Object getObject() throws BeansException {
            try {
                return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
                // Explicitly remove instance from singleton cache: It might have been put there
                // eagerly by the creation process, to allow for circular reference resolution.
                // Also remove any beans that received a temporary reference to the bean.
                destroySingleton(beanName);
                throw ex;
            }
        }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} 
  
调用父类 DefaultSingletonBeanRegistry#getSingleton 方法；注意，这里通过接口 ObjectFactory<Object> 定义了一个回调方法 getObject()，通过该回调方法调用 AbstractAutowireCapableBeanFactory#createBean 方法，通过此回调方法正式拉开了实例化 bean 的序幕。
 
  
Step 1.3.1.1：AbstractAutowireCapableBeanFactory#createBean
 
  
AbstractAutowireCapableBeanFactory#doCreateBean 方法是初始化 bean 的最核心的入口方法，执行流程如 Do Get Bean 流程所示，
 
  
     
   
  1.  
    主流程主要做了这么三件事情，一、instantiate bean；二、populate bean；三、initialize bean；
     
    2.  
   
  2. 包含五个子流程，他们分别是 factory instantiate bean、autwire instantiate bean、default instantiate bean、populate bean 以及 [initialize bean]()，其中，前三个子流程对应第一件事情，[实例化 bean]()；其次的子流程 [populate bean]() 对应的是第二件事情，[为 bean 设置 property 参数]()；最后一个子流程 [initialize bean] 对应最后一件事情既[初始化 bean]()，这里的初始化指的是是对创建好的 bean 做一些修饰动作的。
    3.  
  
 
  
下面我们分别来分析这三件事情
 
  
第一件事情：instantiate bean
 
  
该步骤对应 Do Get Bean 流程中的 Step 1.3.1.1.3.1 createBeanInstance；根据 bean 的不同配置方式，实现了三种实例化 bean 的方式，分别是 factory instantiate bean、autwire instantiate bean 以及 default instantiate bean；
 
  
factory instantiate bean
 
  
用工厂方法实例化 bean，待叙；
 
  
autwire instantiate bean
 
  
通过 autowire 注解的方式实例化 bean，待叙；
 
  
default instantiate bean
 
  
此步骤对应 Do Get Bean 流程中的 Step 1.3.1.1.3.1.3 instantiateBean，其对应子流程 default instantiate bean 如下图所示，
 
  
Spring Core Container 源码分析三：Spring Beans 初始化流程分析_第3张图片
 
  
注意几点
 
  
     
   
  • 这里仅仅是通过使用其构造函数 constructor 使用Java 反射实例化了 bean，并没有对其进行任何的参数赋值，赋值过程参考 populate bean 流程；
    •  
   
  • 将 bean 封装为 BeanWrapper，然后 
    
       
     
    • 注册 default PropertyEditor
      •  
     
    • 注册 custom PropertyEditor
      •  
    
    •  
  
 
  
最后返回 BeanWrapper
 
  
第二件事情：populate bean
 
  
对应 Do Get Bean 流程中的 Step 1.3.1.1.3.4 populateBean，通过调用 AbstractAutowireCapableBeanFactory#populateBean 正式给 bean 的参数进行赋值；为什么方法名取名为populate呢？查百度翻译，结果是居住于、生活于、移民于、落户于的意思，丝毫没有赋值的意思，但是记得以前和美国人共事的时候，他们非常喜欢用这个词populate，特别是在创建某个对象的时候，他们特别喜欢用这个词；后来无意中发现，populate有创建和填充的意思，所以，这里的意思就是，填充这个 bean；下面看看 populate bean 的流程图，看看它是怎么玩的，
 
  
Spring Core Container 源码分析三：Spring Beans 初始化流程分析_第4张图片
 
  
通过调用 AbstractAutowireCapableBeanFactory#applyPropertyValues 方法正式给 bean 进行赋值操作，赋值的主流程主要包括两个部分，resolve property value object 和 set property value to bean
 
  
resolve property value
 
  
对应上面 Sequence Diagram 中的 Step 1.5 - Step 1.7；这一步主要是去遍历当前 bean 所有的 property，并依次解析(resolve)得到对应的 Java 对象；通过方法 BeanDefinitionValueResolver#resolveValueIfNecessary 进行解析，解析的过程是针对不同类型的 Property，采用不同的解析方式，里面目前总共对应了十种类型，先看看它的源码，
 
  
public Object resolveValueIfNecessary(Object argName, Object value) {
    // We must check each value to see whether it requires a runtime reference
    // to another bean to be resolved.
    if (value instanceof RuntimeBeanReference) { // 这里表示该 bean definition ref 引用的是一个 bean，那么这里，必须对该 bean 进行初始化操作；
        RuntimeBeanReference ref = (RuntimeBeanReference) value;
        return resolveReference(argName, ref);
    }
    else if (value instanceof RuntimeBeanNameReference) {
        String refName = ((RuntimeBeanNameReference) value).getBeanName();
        refName = String.valueOf(doEvaluate(refName));
        if (!this.beanFactory.containsBean(refName)) {
            throw new BeanDefinitionStoreException(
                    "Invalid bean name '" + refName + "' in bean reference for " + argName);
        }
        return refName;
    }
    else if (value instanceof BeanDefinitionHolder) {
        // Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
        BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
        return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
    }
    else if (value instanceof BeanDefinition) {
        // Resolve plain BeanDefinition, without contained name: use dummy name.
        BeanDefinition bd = (BeanDefinition) value;
        String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
                ObjectUtils.getIdentityHexString(bd);
        return resolveInnerBean(argName, innerBeanName, bd);
    }
    else if (value instanceof ManagedArray) {
        // May need to resolve contained runtime references.
        ManagedArray array = (ManagedArray) value;
        Class elementType = array.resolvedElementType;
        if (elementType == null) {
            String elementTypeName = array.getElementTypeName();
            if (StringUtils.hasText(elementTypeName)) {
                try {
                    elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
                    array.resolvedElementType = elementType;
                }
                catch (Throwable ex) {
                    // Improve the message by showing the context.
                    throw new BeanCreationException(
                            this.beanDefinition.getResourceDescription(), this.beanName,
                            "Error resolving array type for " + argName, ex);
                }
            }
            else {
                elementType = Object.class;
            }
        }
        return resolveManagedArray(argName, (List) value, elementType);
    }
    else if (value instanceof ManagedList) {
        // May need to resolve contained runtime references.
        return resolveManagedList(argName, (List) value);
    }
    else if (value instanceof ManagedSet) {
        // May need to resolve contained runtime references.
        return resolveManagedSet(argName, (Set) value);
    }
    else if (value instanceof ManagedMap) {
        // May need to resolve contained runtime references.
        return resolveManagedMap(argName, (Map) value);
    }
    else if (value instanceof ManagedProperties) {
        Properties original = (Properties) value;
        Properties copy = new Properties();
        for (Map.Entry propEntry : original.entrySet()) {
            Object propKey = propEntry.getKey();
            Object propValue = propEntry.getValue();
            if (propKey instanceof TypedStringValue) {
                propKey = evaluate((TypedStringValue) propKey);
            }
            if (propValue instanceof TypedStringValue) {
                propValue = evaluate((TypedStringValue) propValue);
            }
            copy.put(propKey, propValue);
        }
        return copy;
    }
    else if (value instanceof TypedStringValue) {
        // Convert value to target type here.
        TypedStringValue typedStringValue = (TypedStringValue) value;
        Object valueObject = evaluate(typedStringValue);
        try {
            Class resolvedTargetType = resolveTargetType(typedStringValue);
            if (resolvedTargetType != null) {
                return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
            }
            else {
                return valueObject;
            }
        }
        catch (Throwable ex) {
            // Improve the message by showing the context.
            throw new BeanCreationException(
                    this.beanDefinition.getResourceDescription(), this.beanName,
                    "Error converting typed String value for " + argName, ex);
        }
    }
    else {
        return evaluate(value);
    }
}  
 
  
这里主要关注两类解析，
 
  
RuntimeBeanReference 类型解析
 
  
对应需要被解析的配置为john的 property spouse，它所对应的值是另一个 bean jane；既是一个去解析一个ref bean。
 
  
  
 
  
所以可以看到，源码中是通过 resolveReference 方法调用 AbstractBeanFactory#getBean 方法去实例化一个 bean jane 并返回；对应的源码如下，
BeanDefinitionValueResolver#resolveReference
 
  
/**
 * Resolve a reference to another bean in the factory.
 */
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
    try {
        String refName = ref.getBeanName();
        refName = String.valueOf(doEvaluate(refName));
        if (ref.isToParent()) {
            if (this.beanFactory.getParentBeanFactory() == null) {
                throw new BeanCreationException(
                        this.beanDefinition.getResourceDescription(), this.beanName,
                        "Can't resolve reference to bean '" + refName +
                        "' in parent factory: no parent factory available");
            }
            return this.beanFactory.getParentBeanFactory().getBean(refName);
        }
        else {
            Object bean = this.beanFactory.getBean(refName); // 去得到这个 ref bean
            this.beanFactory.registerDependentBean(refName, this.beanName); // 注册
            return bean;
        }
    }
    catch (BeansException ex) {
        throw new BeanCreationException(
                this.beanDefinition.getResourceDescription(), this.beanName,
                "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
    }
}  
 
  
通过调用this.beanFactory.getBean(refName)再次进入Do Get Bean 流程初始化得到该 ref bean；
 
  
最后，将解析出来的 Property value 放在一个deepCopy的 ArrayList 列表对象中；顾名思义，就是对值进行了一次深度的拷贝，然后将其作为 bean 的参数，随后开始进行赋值操作)；
 
  
TypedStringValue 类型解析
 
  
这里主要被解析的 Property value 的类型配置为
 
  
 
  
其 Property value 的值在配置文件中就是一个纯的字符串类型；但从源码中可以知道，Property value 是可以包含 value type 的，所以，在解析 TypedStringValue 的时候，需要根据 value type 进行解析；具体逻辑参考resolveTargetType(typedStringValue);方法。
 
  
set property value to bean
 
  
此步骤的主流程主要是通过Java Method 反射将解析出来的值赋值给当前的 bean；对应时序图中的 Step 1.8 setPropertyValues
 
  
可以看到，通过遍历 deepCopy ArrayList 对象中已经解析过后的 PropertyValue，最终由 BeanWrapperImpl 对象通过方法的反射，将值注入给当前的 bean，Step 1.8.1.2.1.2.2 writeMethod.invoke
 
  
BeanWrapperImpl.java 省略了大部分无关紧要的代码，
 
  
@Override
public void setValue(final Object object, Object valueToApply) throws Exception{
    final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
            ((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
            this.pd.getWriteMethod());
    if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers()) && !writeMethod.isAccessible()) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction() {
                @Override
                public Object run() {
                    writeMethod.setAccessible(true);
                    return null;
                }
            });
        }
        else {
            writeMethod.setAccessible(true);
        }
    }

    ....

    writeMethod.invoke(getWrappedInstance(), valueToApply);

    ....
} 
  
通过这一步，将相关的 property populate 给 bean 以后，才算 bean 的实例化完成；
 
  
第三件事情：initialize bean
 
  
正如流程图中所描述的那样，这个步骤的名字非常然人迷惑，我将流程图中写的备注摘录如下，
 
  
"注意, 这里的名称很容易让人产生混淆, 很容易让人产生这样一个疑问, 前面不是已经初始化好了, bean 创建好了, bean 相关的 property 也设置好了, 怎么这里还要进行初始化? 这里其实恰恰充分体现了西方人写代码的严谨, 前面的部分叫做 instantiation, 叫做"实例化", 而这里叫做 initialization, 叫做 "初始化"; 这样一说, 差不多就明白了, "实例化"就是从 class 得到 instance 的过程; 而"初始化", 包含的意义更广泛, 其意义包含了"实例化"和其它对 instance 的修饰的过程, 而这里, 其实就是对已经创建好的 bean instance 进行"修饰"的过程。"
 
  
所以，这里的 initialize 其实就是对通过 instantiate bean 和 populate bean 两个步骤实例化好的 bean 进行后续必要的修饰；我们通过流程图来看看，它是怎么去修饰的，
Spring Core Container 源码分析三：Spring Beans 初始化流程分析_第5张图片
 
  
通过 AbstractAutowireCapableBeanFactory#initializeBean 方法进行对 bean 的修饰过程，看源码，(删除了大部分不相关的代码)
 
  
AbstractAutowireCapableBeanFactory.java
 
  
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {

    invokeAwareMethods(beanName, bean); // 调用实现了 *Aware 接口的方法，比如注入 ApplicationContext... 

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 调用 bean-post-processor 的 before initialization 回调方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 
    }

    try {
        invokeInitMethods(beanName, wrappedBean, mbd); // 调用 InitializingBean#afterPropertiesSet 回调 
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }

    if (mbd == null || !mbd.isSynthetic()) {
        // 调用 bean-post-processor 的 after initialization 回调方法
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); 
    }

    return wrappedBean; // 这里的 wrapped bean 指的是被 bean-post-processor 修饰以后的包装 bean
}
 
  
整个过程可以理解为三大块，
 
  
     
   
  • 注入 Aware 对象，见代码第三行；
    •  
   
  • 回调 bean-post-processors 接口方法，见代码第 9 行和第 23 行；
    •  
   
  • 回调 InitializingBean 接口方法，见代码第 13 行
    •  
  
 
  
下面，我们依次来梳理这三个部分；
 
  
注入 Aware 对象
 
  
对应流程图中的 Step 1.1 invokeAwareMethods，该步骤注册所有实现了Aware接口的 beans
 
  
Aware.java
 
  
/**
 * 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. Actual method signature is
 * determined by individual subinterfaces, but should typically
 * consist of just one void-returning method that accepts a single
 * argument.
 *
 * 
Note that merely implementing {@link Aware} provides no default
 * functionality. Rather, processing must be done explicitly, for example
 * in a {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessor}.
 * Refer to {@link org.springframework.context.support.ApplicationContextAwareProcessor}
 * and {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory}
 * for examples of processing {@code *Aware} interface callbacks.
 *
 * @author Chris Beams
 * @since 3.1
 */
public interface Aware {

}
 
  
从 Aware 接口的注释中可以看到，允许实现了该 Aware 接口的当前 bean 能够有机会通过回调的方式注入 Spring 容器中默认实现了 Aware 接口的 bean，比如 BeanFactory 等；看看源码，
 
  
AbstractAutowireCapableBeanFactory.java
 
  
private void invokeAwareMethods(final String beanName, final Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}
 
  
可以看到，注入了三种情况，
 
  
     
   
  1.  
    当当前 bean 实现了 BeanNameAware 接口，只是调用了 setBeanName；给我目前的感觉是，没有起到什么大的作用，把自己的 beanName 设置给自己，有什么用处？嗯，倒是想到一个，logging；
     
    2.  
   
  2.  
    当当前 bean 实现了 BeanClassLoaderAware 接口，将 Spring 容器的 BeanClassLoader 注入到当前 bean；记住，如果想要获得加载 Bean 当前的 ClassLoader 对象的时候，只需要让 Bean 实现 BeanClassLoaderAware 接口并实现相应接口方法即可。
     
    3.  
   
  3. 当当前 bean 实现了 BeanFactoryAware 接口，将 Spring 容器中与 bean 初始化相关的 BeanFactory 实例(这里对应的是 DefaultListableBeanFactory 实例)注册给当前的 bean。 
    4.  
  
 
  
当梳理完这个部分以后，我相信读者会和我一样有这样的疑问，我们不是经常通过Aware的方式注入ApplicaitonContext对象的吗？但和明显，上述的代码并没有注入ApplicationContext对象呀？看如下部分分析，
 
  
下列部分是延生部分
 
  
但是要特别特别注意的是，这里并没有注入ApplicationContext对象，要注入ApplicaitonContext对象，bean 必须实现ApplicatonContextAware接口；
 
  
ApplicationContextAware.java 
 
  
public interface ApplicationContextAware extends Aware {

    /**
     * Set the ApplicationContext that this object runs in.
     * Normally this call will be used to initialize the object.
     * 
Invoked after population of normal bean properties but before an init callback such
     * as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}
     * or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader},
     * {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and
     * {@link MessageSourceAware}, if applicable.
     * @param applicationContext the ApplicationContext object to be used by this object
     * @throws ApplicationContextException in case of context initialization errors
     * @throws BeansException if thrown by application context methods
     * @see org.springframework.beans.factory.BeanInitializationException
     */
    void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

}
 
  
从注解中可以看到，它明确标注，是在 populate bean 以后，在 处理 InitializingBean 接口回调 之前调用，那是到底是在什么时刻呢？我们查看下方法 setApplicationContext 方法在 workspace 中的引用，它是在 ApplicationContextAwareProcessor#invokeAwareInterfaces 方法中被调用，而 ApplicationContextAwareProcessor 正好是一个 BeanPostProcessor 对象，所以，ApplicaitonContext对象实际上是在 bean-post-procesor before initialization流程中被注入的，看源码，
 
  
ApplicationContextAwareProcessor.java (省略了大部分不相关的代码)
 
  
class ApplicationContextAwareProcessor implements BeanPostProcessor {

    private final ConfigurableApplicationContext applicationContext;

    private final StringValueResolver embeddedValueResolver;

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

    @Override
    public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
        AccessControlContext acc = null;

        ....

        invokeAwareInterfaces(bean);

        ....

        return bean;
    }

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

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }

}
 
  
回调 bean-post-processors 接口方法
 
  
先来看看BeanPostProcessor接口的源码，
 
  
public interface BeanPostProcessor {

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

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

}
 
  
该接口定义了两个回调方法，
 
  
     
   
  •  
    Object postProcessBeforeInitialization(Object bean, String beanName)
    从方法的注释中不难发现，该方法是在回调 InitializeBean 接口方法之前调用，并且是在 populate bean) 之后进行的调用，通常是对原有 bean 做一层封装，然后返回该封装对象；这就是我在前文所描述的，其实就是是对原有 bean 起到修饰的作用；
     
    •  
   
  • Object postProcessAfterInitialization(Object bean, String beanName)
    从方法的注释中不难发现，该方法是在回调 InitializeBean 接口方法之前调用，同样也是在 populate bean) 之后进行的调用
    •  
  
 
  
所以，bean-post-processors 总共有两次调用的时机，分别是 before initialization 和 after initialization，而且要特别注意的是，该回调方法是针对对容器中所有的普通 bean 进行的回调；
 
  
before initialization
 
  
该步骤对应 Step 1.2 applyBeanPostProcessorsBeforeInitialization，然后正式调用 Step 1.2.1 beanPostProcessor.postProcessBeforeInitialization bean-post-processor 的回调方法，不过这里要注意的是，如果 Step 1.2.1 返回 null，会终止余下的 post-bean-processor 的执行，并且直接返回一个 null，该 null 同样被视为是封装后的产物，既然是 null，那么后续的 bean-post-processor 也无需处理了，也无法对原有的 bean 进行包装了.. 不过，我到觉得这里的 Spring 源码的逻辑应该改进一下，不允许返回 null 的情况，如果返回 null 则报错最好，因为 bean-post-processor 是对原有 bean 进行修饰，是新增属性，而非干掉实例本身.. 来看看源码，
 
  
AbstractAutowireCapableBeanFactory.java
 
  
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}
 
  
如果某个 beanProcessor 处理返回一个 null 则直接返回，并且终止其余的 bean-post-processors
 
  
after initialization
 
  
对应的是 step 1.4 applyBeanPostProcessorsAfterInitialization 步骤，里面的逻辑和 before initialization 逻辑类似，不再赘述。
 
  
回调 InitializingBean 接口方法
 
  
该步骤对应的是 Step 1.3: invokeInitMethod，回调 InitializingBean 接口方法，看源码，
 
  
AbstractAutowireCapableBeanFactory.java (删除了大部分不相关的代码)
 
  
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
        throws Throwable {

    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (logger.isDebugEnabled()) {
            logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }
        .....
        ((InitializingBean) bean).afterPropertiesSet();
        .....
    }

    if (mbd != null) {
        String initMethodName = mbd.getInitMethodName();
        if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}
 
  
可以看到，主要回调的是InitializingBean接口的afterPropertiesSet方法，所以，我们可以让某个 bean 实现 InitializingBean 接口，并通过该接口实现一些当 bean 实例化好以后的回调方法，注意afterPropertiesSet并不返回任何值，所以，这里不是像 bean-post-processor 那样对 bean 起到修饰的作用，而是起到纯粹的调用作用；
 
  
总结（我的思考）
 
  
以上便是 Spring IoC 容器的核心实现了，容器要达到的最本质的目的就是IoC既反转控制，由容器来负责管理对象实例相关依赖的初始化和注入，而不再是由 bean 自己去控制自己的依赖的初始化和注入过程了；而IoC的实现是通过DI既是依赖注入实现的；也就是为什么上面所介绍的内容都是围绕着 Spring 容器如何实例化一个 bean，如何赋值，如何进行回调等一系列在 bean 的构建声明周期过程中的种种行为；
 
  
这样做能达到的好处就是，
 
  
     
   
  1.  
    实现了对象的依赖属性和依赖对象的高度可定制化，我们可以通过容器配置的方式，轻松的修改 bean 所的依赖对象，以改变原有的其行为；
     
    (这里我突然想到“微内核架构”，Java 的一种内置的依赖注入的方式，通过在 META-INF 中配置接口属性文件，里面其实就是配置的一个接口的实现类，通过它来控制接口在 JVM 中该接口所使用的实现类；但它只是控制某个接口如何在 JVM 中实现，将接口的实现翻转控制了，而 Spring 是对所有的 Class Instance 进行翻转控制，所以一个是站在局部上的反转控制设计，一个是站在全局上的反转控制设计，不可同日而语！）
     
    2.  
   
  2. 通过 bean-post-processor 扩展点能够对原始的 bean 进行包装，通过这样的方式，我们可以包装得到一个 proxy bean，提供相关的 AOP 操作，比如提供事务，异常处理等等方法注入的实现；
    3.  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring,Spring,Core)

        

            

                
    
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • 你可能遗漏的一些C#/.NET/.NET Core知识点
                        追逐时光者
C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
                        
    前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
    
                    
    • 
                    
  • K近邻算法_分类鸢尾花数据集
                        _feivirus_
算法机器学习和数学分类机器学习K近邻
                        
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • yolov5＞onnx＞ncnn＞apk
                        图像处理大大大大大牛啊
opencv实战代码讲解yoloonnxncnn安卓
                        
    一.yolov5pt模型转onnx条件：colabnotebookyolov51.安装环境!pipinstallonnx>=1.7.0#forONNXexport!pipinstallcoremltools==4.0#forCoreMLexport!pipinstallonnx-simplifier2.修改common.py在classFocus下面
    
                    
    • 
                    
  • HarmonyOS Next鸿蒙扫一扫功能实现
                        JohnLiu_
HarmonyOSNextharmonyos华为扫一扫鸿蒙
                        
    直接使用的是华为官方提供的api，封装成一个工具类方便调用。import{common}from'@kit.AbilityKit';import{scanBarcode,scanCore}from'@kit.ScanKit';exportnamespaceScanUtil{exportasyncfunctionstartScan(context:common.Context):Promise{if
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Gobelieve 架构
                        weixin_34099526
数据库golangjson
                        
    Gobelievegithub地址声明:转简书JackieF的文章,为了自己方便copy了一份,加一些自己的东西.链接：https://www.jianshu.com/p/8121d6e85282IMCore主要分三大块:im客户连接服务器（可分布式部署，暂无负载均衡模块)imr路由查询服务器（主要解决im分布式部署的问题）ims存储服务器(主从部署)基础模块1.数据包协议包：header(12)
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                    
  • day12 控制流程 if switch while do...while 猜数字游戏
                        卓越小Y
JAVA学习日志游戏java开发语言
                        
    控制流程顺序结构所有的程序都是按顺序执行if语句选择结构单选择语句if(a>0){System.out.println(“hello”);}packagecom.ckw.blog.select;importjava.util.Scanner;publicclassdemo01{publicstaticvoidmain(String[]args){intscore=0;Scannerscanner=
    
                    
    • 
                                
  • Nginx负载均衡
                                    510888780
nginx应用服务器
                                    
    Nginx负载均衡一些基础知识: 
 
nginx 的 upstream目前支持 4 种方式的分配 
1)、轮询（默认） 
      每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 
2)、weight 
      指定轮询几率，weight和访问比率成正比
    
                                
    • 
                                
  • RedHat 6.4 安装 rabbitmq
                                    bylijinnan
erlangrabbitmqredhat
                                    
    在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功 
 
机器版本： 
 
[root@redhat1 rabbitmq]# lsb_release
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core
    
                                
    • 
                                
  • FilenameUtils工具类
                                    eksliang
FilenameUtilscommon-io
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述 
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    
                                
    • 
                                
  • xml文件解析SAX
                                    不懂事的小屁孩
xml
                                    
    xml文件解析:xml文件解析有四种方式， 
1.DOM生成和解析XML文档(SAX是基于事件流的解析) 
2.SAX生成和解析XML文档(基于XML文档树结构的解析) 
3.DOM4J生成和解析XML文档 
4.JDOM生成和解析XML  
本文章用第一种方法进行解析，使用android常用的DefaultHandler 
 
 
import org.xml.sax.Attributes;

    
                                
    • 
                                
  • 通过定时任务执行mysql的定期删除和新建分区，此处是按日分区
                                    酷的飞上天空
mysql
                                    
    使用python脚本作为命令脚本，linux的定时任务来每天定时执行 
  
#!/usr/bin/python
# -*- coding: utf8 -*-
import pymysql
import datetime
import calendar

#要分区的表
table_name = 'my_table'
#连接数据库的信息
host,user,passwd,db = 
    
                                
    • 
                                
  • 如何搭建数据湖架构？听听专家的意见
                                    蓝儿唯美
架构
                                    
    Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据 
 “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
    
                                
    • 
                                
  • spring学习——控制反转与依赖注入
                                    a-john
spring
                                    
           控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。 
  

    
                                
    • 
                                
  • 用spool+unixshell生成文本文件的方法
                                    aijuans
xshell
                                    
    例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下:  
　　set pages 50000; 
　　set lines 200; 
　　set trims on; 
　　set heading off; 
　　spool /oracle_backup/log/test/dept.lst; 
　　select deptno||','||dname||','||loc 
    
                                
    • 
                                
  • 1、基础--名词解析(OOA/OOD/OOP)
                                    asia007
学习基础知识
                                    
    OOA:Object-Oriented Analysis（面向对象分析方法） 
是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。 
　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
    
                                
    • 
                                
  • 浅谈java转成json编码格式技术
                                    百合不是茶
json编码java转成json编码
                                    
    json编码;是一个轻量级的数据存储和传输的语言 
   
   在java中需要引入json相关的包,引包方式在工程的lib下就可以了 
  
JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非 
  
常适合于服务器与 JavaScript 之间的数据的交
    
                                
    • 
                                
  • web.xml之Spring配置(基于Spring+Struts+Ibatis)
                                    bijian1013
javaweb.xmlSSIspring配置
                                    
    指定Spring配置文件位置 
<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml,
			/WEB-INF/
    
                                
    • 
                                
  • Installing SonarQube（Fail to download libraries from server）
                                    sunjing
InstallSonar
                                    
    1.  Download and unzip the SonarQube distribution  
2.  Starting the Web Server 
The default port is "9000" and the context path is "/". These values can be changed in &l
    
                                
    • 
                                
  • 【MongoDB学习笔记十一】Mongo副本集基本的增删查
                                    bit1129
mongodb
                                    
    一、创建复本集 
  
假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令： 
  
mongod --port 27017 --dbpath  data1 --replSet rs0

mongod --port 27018 --dbpath  data2 --replSet rs0

mongod --port 27019 -
    
                                
    • 
                                
  • Anychart图表系列二之执行Flash和HTML5渲染
                                    白糖_
Flash
                                    
    今天介绍Anychart的Flash和HTML5渲染功能 
  
 
 HTML5 
 
Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。 
这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
    
                                
    • 
                                
  • Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa
                                    bozch
laravel
                                    
    昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误： 
ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
    
                                
    • 
                                
  • 编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;
import java.util.Random;

public class Nim {

	/**编程之美 NIM游戏分析
问题：
有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头，
能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
    
                                
    • 
                                
  • lunce创建索引及简单查询
                                    chengxuyuancsdn
查询创建索引lunce
                                    
    import java.io.File;
import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Docume
    
                                
    • 
                                
  • [IT与投资]坚持独立自主的研究核心技术
                                    comsci
it
                                    
     
 
       和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段..... 
 
 
       所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
    
                                
    • 
                                
  • flashback transaction闪回事务查询
                                    daizj
oraclesql闪回事务
                                    
       
闪回事务查询有别于闪回查询的特点有以下3个： 
 
（1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。 
 
（2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。 
 
（3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
    
                                
    • 
                                
  • Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件
                                    游其是你
FilenameFilter
                                    
    这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28  
    
                                
    • 
                                
  • C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int f(void)		//括号中的void表示该函数不能接受数据，int表示返回的类型为int类型
{
	return 10;	//向主调函数返回10
}

void g(void)	//函数名前面的void表示该函数没有返回值
{
	//return 10;	//error 与第8行行首的void相矛盾
}

in
    
                                
    • 
                                
  • 今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl
                                    dcj3sjt126com
centos
                                    
    今天在测试环境使用yum安装，遇到一个问题： 
Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again 
  
处理很简单，修改文件“/etc/yum.repos.d/epel.repo”， 将baseurl的注释取消， mirrorlist注释掉。即可。 
&n
    
                                
    • 
                                
  • 单例模式
                                    shuizhaosi888
单例模式
                                    
    单例模式        懒汉式 
public class RunMain {

	/**
	 * 私有构造
	 */
	private RunMain() {
	}
	
    /**
     * 内部类，用于占位，只有
     */
	private static class SingletonRunMain {
		priv
    
                                
    • 
                                
  • Spring Security（09）——Filter
                                    234390216
Spring Security
                                    
    Filter 
目录 
1.1     Filter顺序 
1.2     添加Filter到FilterChain 
1.3     DelegatingFilterProxy 
1.4     FilterChainProxy 
1.5
    
                                
    • 
                                
  • 公司项目NODEJS实践0.1
                                    逐行分析JS源代码
mongodbnginxubuntunodejs
                                    
      
一、前言 
        前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。 
        网上有很多nod
    
                                
    • 
                                
  • java.lang.Math
                                    liuhaibo_ljf
javaMathlang
                                    
    System.out.println(Math.PI); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1)); 
System.out.println(Math.abs(111111111)); 
System.out.println(Mat
    
                                
    • 
                                
  • linux下时间同步
                                    nonobaba
ntp
                                    
    今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误  PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
    
                                
    • 
                                
  • ZooKeeper3.4.6的集群部署
                                    roadrunners
zookeeper集群部署
                                    
    ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。 
  
1、准备工作 
我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。 
  
数据存储目录
    
                                
    • 
                                
  • Java高效读取大文件
                                    tomcat_oracle
java
                                    
    　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法：   　　Files.readLines(new File(path), Charsets.UTF_8);   　　FileUtils.readLines(new File(path));   　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
    
                                
    • 
                                
  • 微信支付api返回的xml转换为Map的方法
                                    xu3508620
xmlmap微信api
                                    
    举例如下： 
<xml> 
   <return_code><![CDATA[SUCCESS]]></return_code> 
   <return_msg><![CDATA[OK]]></return_msg> 
   <appid><
    
                                
    •