吴一尘
吴一尘

Spring源码阅读之bean对象的创建过程

Spring源码阅读之bean对象的创建过程

​ Spring是通过IOC容器来管理对象的，该容器不仅仅只是帮我们创建了对象那么简单，它负责了对象的整个生命周期-创建、装配、销毁。这种方式成为控制反转（组件对象控制权的转移，从程序代码本身转移到了外部容器，容器创建完对象后注入组件中）。

​ Spring的核心的是容器，不过这个容器并不是唯一的，框架本身就提供了很多个容器的实现，大概分为两种类型：

  1. BeanFactory：最简单的容器，只能提供基本的DI（依赖注入）功能。
  2. ApplicationContext（应用上下文）：继承自BeanFactory，它能提供更多企业级的服务，例如解析配置文本信息等等，这也是ApplicationContext实例对象最常见的应用场景。

简单说说这两种方式的区别：

  1. 原始的BeanFactory无法支持spring的许多插件，如AOP功能、Web应用
  2. ApplicationContext利用MessageSource进行国际化 并有着事件机制。
  3. ApplicationContext扩展了ResourceLoader(资源加载器)接口，从而可以用来加载多个Resource，而BeanFactory是没有扩展ResourceLoader
  4. 与BeanFactory通常以编程的方式被创建不同的是，ApplicationContext能以声明的方式创建，如使用ContextLoader。当然你也可以使用ApplicationContext的实现之一来以编程的方式创建ApplicationContext实例 。
  5. BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化，这样，我们就不能发现一些存在的spring的配置问题。而ApplicationContext则相反，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误。

ApplicationContext 介绍

​ 如果说BeanFactory是Sping的心脏，那么ApplicationContext就是完整的身躯了。ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。在Beanfactory中，很多功能需要以编程的方式实现，而在ApplicationContext中则可以通过配置的方式实现。

ApplicationContext类体系结构：
Spring源码阅读之bean对象的创建过程_第1张图片

在上一篇源码阅读WebContextApplication初始化中说到实际创建的对象为XmlWebApplicationContext，该类继承了AbstractRefreshableWebApplicationContext（上图的左下角），也是ApplicationContext体系。那么该对象读取配置文件后是如何创建bean对象的呢？

大致分为两步:

  1. 实例化BeanDefinition对象（下面分析该对象的作用） 。

  2. 实例化bean对象。

1. 实例化BeanDefinition对象

WebContextApplication初始化说到初始化的步骤是在ContextLoader中完成,创建完XmlWebApplicationContext对象后，通过configureAndRefreshWebApplicationContext()设置配置文件的位置。

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
        String configLocationParam;
        if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
            configLocationParam = sc.getInitParameter("contextId");
            if (configLocationParam != null) {
                wac.setId(configLocationParam);
            } else {
                wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(sc.getContextPath()));
            }
        }
		//设置ServletContext环境。
        wac.setServletContext(sc);
    	/*读取Servlet对象中的contextConfigLocation.  ServletContext在创建的时候就读取了
    		标签,并将该标签中的配置文件的信息通过键值对的形式保存进来了。
    	*/
        configLocationParam = sc.getInitParameter("contextConfigLocation");
        if (configLocationParam != null) {
            //保存配置文件信息的位置。
            wac.setConfigLocation(configLocationParam);
        }
		//刷新环境
        wac.refresh();
    }

​ 配置文件位置设置完成后就需要读取该文件的配置信息，并创建相应的bean对象，这一过程就是在refresh()中完成的。

​ 通过图中的继承关系往上寻找在AbstractApplicationContext中发现·refresh方法，

该方法进行一些初始化操作。

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            // 1.刷新前的预处理,包含设置启动时间、设置状态...
            this.prepareRefresh();
             //实现刷新BeanFactory，将配置文件解析为BeanDefinition并注册到BeanFactory，此时Bean还未被初始化
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            // BeanFactory的预准备工作
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                // 执行BeanFactoryPostProcessor的方法，BeanFactory的后置处理器 
                // 在BeanFactory标准初始化之后执行的
                this.invokeBeanFactoryPostProcessors(beanFactory);
                // 注册BeanPostProcessor（Bean的后置处理器）,用于拦截bean创建过程
                this.registerBeanPostProcessors(beanFactory);
                // 初始化MessageSource组件（做国际化功能；消息绑定，消息解析).
                this.initMessageSource();
                // 初始化上下文的事件机制
                this.initApplicationEventMulticaster();
                // 可以用于子类实现在容器刷新时自定义逻辑初始化
                this.onRefresh();
                // 注册时间监听器，将ApplicationListener注册到容器中来
                this.registerListeners();
                // 初始化所有剩下的单实例bean,单例bean在初始化容器时创建。
                this.finishBeanFactoryInitialization(beanFactory);
                // 发布完成事件，结束初始化过程
                this.finishRefresh();
            } catch (BeansException var5) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt", var5);
                this.destroyBeans();
                this.cancelRefresh(var5);
                throw var5;
            }

        }
    }

​ obtainFreshBeanFactory将配置文件解析为BeanDefinition并注册到BeanFactory中

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
     // 主要是通过该方法完成IoC容器的刷新
        this.refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
        }

        return beanFactory;
    }

​ refreshBeanFactory完成IOC容器的刷新，具体实现是在AbstractRefreshableApplicationContext中，实际创建的的IOC容器为：DefaultListableBeanFactory

protected final void refreshBeanFactory() throws BeansException {
    //首先检查是否已经有beanFactory了，有就销毁
        if (this.hasBeanFactory()) {
            this.destroyBeans();
            this.closeBeanFactory();
        }

        try {
          // 创建IoC容器，也就是DefaultListableBeanFactory
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            beanFactory.setSerializationId(this.getId());
            this.customizeBeanFactory(beanFactory);
            //载入刚创建的IOC容器，具体实现在子类XmlWebApplicationCpntext中
            this.loadBeanDefinitions(beanFactory);
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }

​ loadBeanDefinitions装载刚创建的IOC容器，具体实现在XmlWebApplicationCpntext中。

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // 创建一个BeanDefinition阅读器，通过阅读XML文件，真正完成BeanDefinition的加载和注册
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    //beanDefinitionReaderde 初始化操作
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
        this.initBeanDefinitionReader(beanDefinitionReader);
        this.loadBeanDefinitions(beanDefinitionReader);
    }
//方法重载
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
    /*在上一篇文章中ContextLoader中的configureAndRefreshWebApplicationContext方法有这一段代码
     configLocationParam = sc.getInitParameter("contextConfigLocation");
        if (configLocationParam != null) {
            //保存配置文件信息的位置。
            wac.setConfigLocation(configLocationParam);
        }
        这里就是读取配置文件的信息，保存进数组中。
    */
        String[] configLocations = this.getConfigLocations();
        if (configLocations != null) {
            String[] var3 = configLocations;
            int var4 = configLocations.length;
            for(int var5 = 0; var5 < var4; ++var5) {
                String configLocation = var3[var5];
                //具体的装载方法在XmlBeanDefinitionReader
                reader.loadBeanDefinitions(configLocation);
            }
        }

    }

​ 接下来看XmlBeanDefinitionReader中的loadBeanDefinitions()

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    	// 对配置文件进行编码处理
        return this.loadBeanDefinitions(new EncodedResource(resource));
}
//截取主要代码
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    try {
        //将配置文件转换成流对象
                InputStream inputStream = encodedResource.getResource().getInputStream();

                try {
                    // 从InputStream中得到XML的解析源
                    InputSource inputSource = new InputSource(inputStream);
                    if (encodedResource.getEncoding() != null) {
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
					 // 这里是具体的读取过程，var5等于新注册的BeanDefintion数量
                    var5 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                } finally {
                    inputStream.close();
                }
    
}

​ 具体的读取过程在doLoadBeanDefinitions()中,该方法的主要作用就是：

  • 一个是对XML文件进行DOM解析
  • 一个是完成BeanDefinition对象的加载与注册
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
        try {
            //把资源文件转换成Document对象
            Document doc = this.doLoadDocument(inputSource, resource);
            // 通过对Document对象的操作，完成BeanDefinition的加载和注册工作
            return this.registerBeanDefinitions(doc, resource);
        }Catch(){
		}
    }

​ 看看registerBeanDefinitions()具体完成了哪些操作：

  1. 创建DefaultBeanDefinitionDocumentReader用来解析Document对象。
  2. 获得容器中已注册的BeanDefinition数量
  3. 委托给DefaultBeanDefinitionDocumentReader来完成BeanDefinition的加载、注册工作。
  4. 统计新注册的BeanDefinition数量
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    //  1.
        BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader();
        documentReader.setEnvironment(this.getEnvironment());
    // 2.
        int countBefore = this.getRegistry().getBeanDefinitionCount();
    // 3. 解析过程入口，BeanDefinitionDocumentReader只是个接口，具体的实现过程在DefaultBeanDefinitionDocumentReader完成
        documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource));
    // 4.
        return this.getRegistry().getBeanDefinitionCount() - countBefore;
    }

​ 接着看DefaultBeanDefinitionDocumentReader中的registerBeanDefinitions()该方法：

  • 获得Document的根元素标签
  • 真正实现BeanDefinition解析和注册工作
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        this.logger.debug("Loading bean definitions");
    	//获取文档对象的子节点。
        Element root = doc.getDocumentElement();
    	//真正的解析注册方法
        this.doRegisterBeanDefinitions(root);
    }

​ 到这一步接下来就是对解析文档中的每一个标签节点，获取标签中的属性。创建AbstractBeanDefinition对象，并将标签中属性保存进对象中。具体的步骤就不展示了。

​ 综上步骤具体完成了以下操作：

  1. 创建IoC容器（DefaultListableBeanFactory）

  2. 加载解析XML文件（最终存储到Document对象中）

  3. 读取Document对象，并完成BeanDefinition的加载和注册工作

    BeanDefinition 在 spring 中贯穿始终，spring 要根据 BeanDefinition 对象来实

例化 bean，只有把解析的标签，扫描的注解类封装成 BeanDefinition 对象，spring

**才能实例化 bean **

​ 上面的步骤只是完成了AbstractApplicationContext中refresh()这句话（心累…）

ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

​

2. 实例化Bean对象

​ 进入AbstractApplicationContext中的finishBeanFactoryInitialization()

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        beanFactory.setTempClassLoader((ClassLoader)null);
        beanFactory.freezeConfiguration();
     	// 实例化剩余的单例bean（非懒加载方式）
    	// 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
        beanFactory.preInstantiateSingletons();
    }

进入DefaultListableBeanFactory中的preInstantiateSingletons()方法：

  • 通过beanName获取bean实例，如果获取到的实例不满足条件就看最后一行getBean(beanName)；
  • 核心代码 getBean(beanName);
@Override
    public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Pre-instantiating singletons in " + this);
        }
        // 得到Bean定义名称
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
        // 触发所有非懒加载方式的单例bean的创建
        for (String beanName : beanNames) {
        // 遍历得到对应的bean定义信息
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            // 如果bean不是抽象的，而且是单例的，同时还不是懒加载的，则进行下面的操作
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                // 如果bean是一个工厂bean，则走下面的方法 ，和普通bean区别就是还可以生成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<Boolean>)
                                            ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else { // 普通bean走下面的方法
                    getBean(beanName);
                }
            }
        }

​ 进入AbstractBeanFactory通过doGetBean()方法获取Bean的实例(只展示关键代码)

  1. 通过getSingleton(beanName)方法去缓存中获取单例Bean（第一次初始化，缓存中不存在）

  2. 如果取出来的bean实例是factoryBean的实例，则需要从factoryBean中产生一个Bean对象

  3. 根据当前的beanfactory获取父一级的beanFactory,递归查找我们需要的Bean（Bean是早不到的，第一次初始化）

  4. 获取实例化Bean的BeanDefinition对象

  5. 一般是单例Bean，用匿名内部类的写法，创建单例Bean

    @Override
    public Object getBean(String name) throws BeansException {
        // 获取Bean的实例
        return doGetBean(name, null, null, false);
    }


@SuppressWarnings("unchecked")
    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

        // 获取bean名称
        final String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        // 从缓存中获取单例bean
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) { //如果获取到单例bean，则走下面代码
            if (logger.isDebugEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            // 如果取出来的Bean实例是FactoryBean的Bean实例，则需要从FactoryBean实例中产生一个对象实例。
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else {//如果没有获取到单例bean，则走下面代码
            try {
                // 获取要实例化的bean的BeanDefinition对象
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                // 检查该BeanDefinition对象对应的Bean是否是抽象的
                checkMergedBeanDefinition(mbd, beanName, args);

                // 如果是单例的Bean，请下面的代码
                if (mbd.isSingleton()) {                    //匿名内部类的写法
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            // 创建单例Bean的主要方法
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                   
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
                      return (T) bean;
}

    进一步看看createBean()具体实现在AbstractAutowireCapableBeanFactory中

    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
//省略一些代码
    try {
            // 完成Bean实例的创建（实例化、填充属性、初始化）
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isDebugEnabled()) {
                logger.debug("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }
****

    doCreateBean完成Bean实例的创建（实例化、填充属性、初始化）

    • bean初始化第一步，默认调用无参数构造实例化bean
    • bean初始化第二步，填充属性（DI依赖注入发生在此步骤）
    • bean初始化第三步，调用初始化方法，完成bean的初始化操作AOP发生在此步骤）
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

        // Instantiate the bean.
        // 用BeanWrapper来持有创建出来的Bean对象
        BeanWrapper instanceWrapper = null;
        // 如果是单例的话，则先把缓存中的bean清除
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        // bean初始化第一步：默认调用无参构造实例化Bean
        // 构造参数依赖注入，就是发生在这一步
                // 为了下一步populateBean方法的属性注入做准备
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        // 实例化后的Bean对象
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        // Allow post-processors to modify the merged bean definition.
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        // 解决循环依赖的关键步骤
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        // 如果需要提前暴露单例Bean，则将该Bean放入三级缓存中
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            // 将刚创建的bean放入三级缓存中singleFactories(key是beanName，value是FactoryBean)
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            // bean初始化第二步：填充属性（DI依赖注入发生在此步骤）
            populateBean(beanName, mbd, instanceWrapper);
            // bean初始化第三步：调用初始化方法，完成bean的初始化操作（AOP发生在此步骤）
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
******************************************
}

    进入上面的initializeBean()方法:

    • 应用BeanPostProcessor的postProcessBeforeInitialization方法在初始化之前被调用
    • 执行初始化方法（先调用InitializingBean的afterPropertiesSet，再调用init-method属性指定的初始化方法,最后BeanPostProcessor的postProcessAfterInitialization）
    • 应用BeanPostProcessor的postProcessAfterInitialization方法(AOP代理对象生成)在初始化之后被调用
    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            /*判断beanName是哪个接口的的实现类
        如果bean是BeanNameAware接口的实现类会调用setBeanName方法、
      	如果bean是BeanClassLoaderAware接口的实现类会调用setBeanClassLoader方法、
      	如果是BeanFactoryAware接口的实现类会调用setBeanFactory方法，注入对应的属性值。*/
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //应用BeanPostProcessor的postProcessBeforeInitialization方法
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            //执行初始化方法（先调用InitializingBean的afterPropertiesSet，再调用init-method属性指定的初始化方法）
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        if (mbd == null || !mbd.isSynthetic()) {
            //应用BeanPostProcessor的postProcessAfterInitialization方法(AOP代理对象生成)
            // AOP是等着对象创建完毕，在进行增强
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

    调用初始化方法invokeInitMethods()

    • 判断是否是InitializingBean接口的实现类，如果是县初始化InitializingBean
    • 如果不是则调用InitializingBean接口中的afterPropertiesSet方法
    • 然后再初始化标签对应的init-method属性中的方法
    protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {

        boolean isInitializingBean = (bean instanceof InitializingBean);
        // 如果是InitializingBean接口的实现类，则先初始化InitializingBean的实现类
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction) () -> {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                // 调用InitializingBean接口的afterPropertiesSet方法
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }

        // 然后再初始化标签对应的init-method属性中的方法
        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) &&
                    !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                // 调用自定义的初始化方法
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }
 
    在initializeBean方法中调用BeanPostProcessor的applyBeanPostProcessorsAfterInitialization方法
     
    
       
     
    • 在初始化Bean的时候都会调用每一个配置的BeanPostProcessor的方法
      •  
    
     
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;
        Iterator var4 = this.getBeanPostProcessors().iterator();

        do {
            if (!var4.hasNext()) {
                return result;
            }

            BeanPostProcessor beanProcessor = (BeanPostProcessor)var4.next();
            //bean初始化后调用
            result = beanProcessor.postProcessAfterInitialization(result, beanName);
        } while(result != null);

        return result;
    }

     
    BeanPostProcessor是Spring IOC容器给我们提供的一个扩展接口。接口声明如下：
     
    public interface BeanPostProcessor {
    //bean初始化方法调用前被调用
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    //bean初始化方法调用后被调用
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}


     
    至此bean的初始化就完成了。
      
   
  
    tProcessor)var4.next();
     //bean初始化后调用
     result = beanProcessor.postProcessAfterInitialization(result, beanName);
     } while(result != null);
     
  
           return result;
   }

     
  
    
BeanPostProcessor是Spring IOC容器给我们提供的一个扩展接口。接口声明如下：

```java
public interface BeanPostProcessor {
    //bean初始化方法调用前被调用
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    //bean初始化方法调用后被调用
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}


     
  
    至此bean的初始化就完成了。
     参考：https://www.jianshu.com/p/32dacf644062 作者：GGarrett
     
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(Spring框架,Spring源码,bean对象初始化,BeanDefinition)
    
        
    
            
    
                
      
                    
    • SpringMVC的执行流程
                        

                        
      1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
      
                    
      • 
                    
    • Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】
                        Tony666688888
javawindows开发语言
                        
      针对集合排序，java8可以用Stream流的sorted()进行排序。示例Bean以下我们会使用这个Bean来做示例。publicclassOrder{privateStringweight;privateDoubleprice;privateStringdateStr;//忽略getter、setter、构造方法、toString}字段排序首先是比较器Comparator，形式如下：Compa
      
                    
      • 
                    
    • Spring Boot 2整合Druid的两种方式
                        玩代码
springboot后端javaDruid
                        
      一、自定义整合Druid（非Starter方式）适用于需要完全手动控制配置的场景添加依赖（pom.xml）com.alibabadruid1.2.8org.springframework.bootspring-boot-starter-jdbc创建配置类@ConfigurationpublicclassDruidConfig{@Bean@ConfigurationProperties(prefix
      
                    
      • 
                    
    • 构建高性能Web应用：深入Spring WebFlux
                        李多田

                        
      本文还有配套的精品资源，点击获取简介：SpringWebFlux是Spring框架的一部分，支持反应式编程模型，适合高并发和低延迟Web应用。它提供了非阻塞I/O和事件驱动模型，优化了多核处理器资源的使用。SpringWebFlux拥有两种编程模式，核心组件包括WebHandler,RouterFunction,WebFilter,和WebSession。它与高性能服务器集成，并提供反应式HTTP
      
                    
      • 
                    
    • Spring Boot与云原生：微服务架构的创新实践
                        tmjpz04412
springkubernetes云原生javagraphql
                        
      引言：Spring生态的演进与现状Spring框架的发展历程与核心设计理念当前Spring生态的核心组件（SpringBoot、SpringCloud、SpringData等）行业对Spring生态的依赖与创新需求SpringBoot的创新实践1.自动化配置与启动优化条件装配（@Conditional）的深度定制案例启动类加载机制与类路径扫描优化示例：通过自定义Starter实现快速集成第三方服务
      
                    
      • 
                    
    • 使用Java和Spring WebFlux构建响应式微服务
                        微赚淘客系统开发者@聚娃科技
javaspring开发语言
                        
      使用Java和SpringWebFlux构建响应式微服务大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们将探讨如何使用Java和SpringWebFlux构建响应式微服务。SpringWebFlux是Spring框架的一部分，专为创建响应式应用程序而设计。在这篇文章中，我们将介绍如何使用SpringWebFlux构建响应式微服务，包括基本概念、代码示例以及如何
      
                    
      • 
                    
    • Spring AI Alibaba 快速入门指南（适合初学者）
                        会飞的架狗师
AIspring人工智能java
                        
      如果你是刚接触AI开发或Spring框架的初学者，不用担心，本指南会用简单易懂的语言带你一步步了解并使用SpringAIAlibaba。一、什么是SpringAIAlibaba（小白也能懂）简单来说，SpringAIAlibaba就是一个“工具包”，它把阿里巴巴的AI技术（比如通义千问大模型、向量数据库等）和大家常用的Spring框架“打包”到了一起。**打个比方：**就像你想做蛋糕（开发AI应用
      
                    
      • 
                    
    • Spring框架深度解析
                        

                        
      我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队
      
                    
      • 
                    
    • Spring框架核心技术解析
                        

                        
      我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队
      
                    
      • 
                    
    • [JAVAEE] Thymeleaf 基本语法: form相关标签
                        CN-Dust
JAVAEEspringjava-ee
                        
      th:action指定表单提交地址th:value给value属性赋值th:field能自动生成id、name和value属性form表单示例运行结果更改数据点击保存控制器代码:TestController.javapackagecom.example.demo.controller;importcom.example.demo.bean.Student;importorg.springframe
      
                    
      • 
                    
    • Hutool Java工具类库-ExcelUtil
                        〃冷·夏ぐ
Hutooljavaexcel
                        
      目录依赖:ExcelReader（Excel读取）:1.从文件中读取Excel为ExcelReader2.从流中读取Excel为ExcelReader3.读取指定的sheet4.读取Excel中所有行和列，都用列表表示5.读取为Map列表，默认第一行为标题行，Map中的key为标题，value为标题对应的单元格值6.读取为Bean列表，Bean中的字段名为标题，字段值为标题对应的单元格值Excel
      
                    
      • 
                    
    • Java Web开发核心技术解析与实践指南
                        2301_81709812
java前端开发语言
                        
      目录一、JavaWeb开发基础1.1核心概念解析1.2开发环境搭建二、Servlet与JSP核心技术2.1Servlet编程深度解析生命周期管理（关键代码示例）：核心对象关系：2.2JSP进阶开发技巧动态页面模板示例：三、Spring框架整合开发3.1SpringMVC核心原理3.2现代开发方案对比四、项目实战：图书管理系统4.1系统架构设计4.2性能优化策略五、学习路线建议一、JavaWeb开发
      
                    
      • 
                    
    • Spring Boot 默认使用 CGLIB，但CGLIB 无法代理 final 类或 final 方法
                        yourkin666
springboot后端java
                        
      那么当这两件事冲突时，SpringBoot是怎么“解决”的呢？答案是：它不解决，也无法解决。当这种情况发生时，你的应用程序会直接启动失败。这不是SpringBoot的疏忽，而是由CGLIB的底层原理和Java语言的规则所决定的。工作流程和失败原因让我们来模拟一下SpringBoot启动时会发生什么：Spring容器开始创建所有的Bean。它找到了一个需要被AOP增强的Bean（例如，一个被@Ser
      
                    
      • 
                    
    • Spring 框架中获取 org.w3c.dom.Document 对象的完整流程
                        探索java
Springjavaspring
                        
      引言在Java开发中，XML是一种广泛使用的格式，用于定义配置文件、数据交换等场景。在Spring框架中，XML文件常用于配置应用程序上下文（如applicationContext.xml），或者处理外部系统传输的XML数据。org.w3c.dom.Document是JavaDOMAPI的核心接口，表示一个XML文档的树形结构，允许开发者以编程方式访问和操作XML的内容。Spring框架本身并不直
      
                    
      • 
                    
    • 深入解析 Spring 获取 XML 验证模式的过程
                        探索java
Springspringxmljava
                        
      关键要点Spring的XML验证模式：Spring框架在加载XML配置文件时，会根据文件内容判断使用DTD（文档类型定义）或XSD（XML模式定义）进行验证。自动检测机制：Spring默认使用自动检测（VALIDATION_AUTO）来确定验证模式，通过检查XML文件是否包含DOCTYPE声明来决定使用DTD或XSD。XSD的优先级：Spring倾向于使用XSD，因为它支持命名空间、复杂数据类型和
      
                    
      • 
                    
    • 深入理解 Spring IOC：从概念到实践
                        十六点五
spring后端java
                        
      目录一、引言二、什么是IOC？2.1控制反转的本质2.2类比理解三、SpringIOC的核心组件3.1IOC容器的分类3.2Bean的生命周期四、依赖注入（DI）的三种方式4.1构造器注入4.2Setter方法注入4.3注解注入（推荐）五、案例演示：从XML配置到注解驱动5.1XML配置方式5.2注解驱动方式（推荐）六、SpringIOC的优势与注意事项6.1核心优势6.2注意事项七、总结一、引言
      
                    
      • 
                    
    • Spring框架核心技术解析
                        我是廖志伟
Java场景面试宝典SpringFrameworkDependencyInjectionAOP
                        
      我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队
      
                    
      • 
                    
    • Spring Boot Starter深度解析与实践
                        t0_54coder
编程问题解决手册springboot后端java编程开发
                        
      SpringBootStarter深度解析与实践简介SpringBoot是一个开源Java基础框架，用于创建独立、生产级的基于Spring框架的应用程序。它设计时考虑了无需进行大量的XML配置，通过starters提供依赖管理，简化了项目配置。SpringBootStarter概览SpringBoot的starters是一组jar依赖，它们提供了一种快速配置应用程序的方式，而无需手动包含许多相关的
      
                    
      • 
                    
    • Spring框架核心技术解析
                        我是廖志伟
Java场景面试宝典SpringFrameworkDependencyInjectionAOP
                        
      我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队
      
                    
      • 
                    
    • Spring 容器注入时查找 Bean 的完整规则
                        半部论语
SpringBoot高效的Java开发实践springjava后端springboot
                        
      Spring容器注入时查找Bean的完整规则彻底搞懂SpringIoC在运行时到底“先找谁、再找谁、如何决策”，一文掌握源码级细节。一、为什么要谈“查找规则”？在Spring应用中，我们最常见的代码是：@AutowiredprivateOrderServiceorderService;容器启动后，Spring必须回答两个问题：有哪些候选Bean？最终注入哪一个？这两个问题的答案，就是Spring容
      
                    
      • 
                    
    • ServletRegistrationBean相关知识点
                        

                        
      ServletRegistrationBean相关知识点ServletRegistrationBean是SpringBoot中用于注册和配置Servlet组件的工具类，它简化了传统JavaWeb中通过web.xml配置Servlet的流程，允许以编程方式注册自定义Servlet并设置其映射规则等属性。1.核心作用在SpringBoot应用中，ServletRegistrationBean的主要功能
      
                    
      • 
                    
    • Spring框架核心技术揭秘
                        MoneyHacksPro
Java场景面试宝典SpringFrameworkDependencyInjectionInversionofControl
                        
      我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、Spri
      
                    
      • 
                    
    • @RefreshScope 核心原理深度解析：Spring Boot 的动态魔法
                        zc-code
动态刷新配置文件nacosspringboot后端java
                        
      让我们通过全新的原理图解和代码级分析，揭开@RefreshScope实现配置热更新的神秘面纱！一、工作原理全景图（优化版）开发者/运维配置文件SpringBoot应用Spring容器动态代理ClientNewBean修改配置文件内容发送POST/actuator/refresh触发RefreshEvent事件标记@RefreshScopeBean过期调用Bean方法检查Bean是否过期？销毁旧Be
      
                    
      • 
                    
    • “Java开发者必备神器：掌握 BeanUtils，这篇就够了！”
                        代码魔法师Sunny
Javajava开发语言
                        
      在日常Java开发中，数据对象的复制与转换是一个常见需求，但手动编写代码容易出错且效率低下。而ApacheCommons提供的BeanUtils工具类，就像一把瑞士军刀，可以轻松应对这些场景！本文将带你全面掌握BeanUtils的用法，附带完整示例，轻松入门！概括：作用将一个对象转换成另外一个对象ApacheCommons下的包1.什么是BeanUtils?BeanUtils是ApacheComm
      
                    
      • 
                    
    • C++11：智能指针
                        双马尾为什么是神
c++开发语言
                        
      一.概览智能指针是在头文件中的std命名空间中定义的。它们对RAII或“获取资源即初始化”编程惯用法至关重要。此习惯用法的主要目的是确保资源获取与对象初始化同时发生，从而能够创建该对象的所有资源并在某行代码中准备就绪。实际上，RAII的主要原则是为将任何堆分配资源（例如，动态分配内存或系统对象句柄）的所有权提供给其析构函数包含用于删除或释放资源的代码以及任何相关清理代码的堆栈分配对象。大多数情况下
      
                    
      • 
                    
    • 【 Python 】Collections库权威指南
                        满怀1015
Python进阶精讲python开发语言
                        
      目录PythonCollections库权威指南：高效数据容器的秘密武器一、为什么需要Collections模块？原生数据结构的局限性Collections的解决方案二、核心数据结构详解（附实战案例）1.Counter-元素计数器基础用法高级操作Counter对象初始化的方法2.defaultdict-自动初始化字典类型工厂模式自定义工厂函数3.deque-双端队列基础操作高级应用4.namedt
      
                    
      • 
                    
    • MyBatis Plus 分页
                        中东大鹅
mybatisjava数据库springboot
                        
      一、分页插件MyBatisPlus自带分页插件，只要简单的配置即可实现分页功能1、添加配置类@ConfigurationpublicclassMyConfig{@BeanpublicMybatisPlusInterceptormybatisPlusInterceptor(){MybatisPlusInterceptorinterceptor=newMybatisPlusInterceptor();
      
                    
      • 
                    
    • Spring解决循环依赖问题
                        leese233
springjava后端
                        
      Spring通过三级缓存来解决循环依赖问题在Spring中，三级缓存机制用于管理Bean的创建和缓存。它包括以下三个层次：一级缓存：单例池（SingletonPool）二级缓存：早期引用（EarlySingletonObjects）三级缓存：singletonFactories一级缓存（单例池）一级缓存是Spring中的单例池，用于存储已经创建的单例Bean。当第一次请求某个Bean时，Sprin
      
                    
      • 
                    
    • 别让 @Transactional 再次“失效”！Spring 事务管理的 5 大避坑指南
                        

                        
      在几乎所有的企业级Java应用中，数据的一致性都是至关重要的。Spring框架提供的@Transactional注解，以其声明式的优雅，极大地简化了数据库事务管理。开发者只需在方法上添加一个注解，就能获得由Spring精心编排的事务支持。然而，这份“简单”的背后，隐藏着基于AOP代理的复杂机制。如果对它的工作原理缺乏了解，就很容易陷入各种“事务失效”的陷阱——代码看起来没问题，但在特定场景下，事务
      
                    
      • 
                    
    • 【源码分析】Spring如何解析xml文件生成BeanDefinition
                        

                        
      4.1Spring如何解析xml文件生成BeanDefinition源码版本：5.3.x|构建一套本地Spring源码，学习起来真的是太方便了！从容器启动开始不断Debug，发现Spring中将xml文件的bean的信息转换为BeanDefinition的类为XmlBeanDefinitionReader等一些列的类下面将直接从核心方法开始进行一步步解析。XmlBeanDefinitionRead
      
                    
      • 
                                
    • 开发者关心的那些事
                                    圣子足道
ios游戏编程apple支付
                                    
      我要在app里添加IAP，必须要注册自己的产品标识符（product identifiers）。产品标识符是什么？ 
产品标识符（Product Identifiers）是一串字符串，它用来识别你在应用内贩卖的每件商品。App Store用产品标识符来检索产品信息，标识符只能包含大小写字母（A-Z）、数字（0-9）、下划线（-）、以及圆点(.)。你可以任意排列这些元素，但我们建议你创建标识符时使用
      
                                
      • 
                                
    • 负载均衡器技术Nginx和F5的优缺点对比
                                    bijian1013
nginxF5
                                    
              对于数据流量过大的网络中，往往单一设备无法承担，需要多台设备进行数据分流，而负载均衡器就是用来将数据分流到多台设备的一个转发器。 
        目前有许多不同的负载均衡技术用以满足不同的应用需求，如软/硬件负载均衡、本地/全局负载均衡、更高
      
                                
      • 
                                
    • LeetCode[Math] - #9 Palindrome Number
                                    Cwind
javaAlgorithm题解LeetCodeMath
                                    
      原题链接：#9 Palindrome Number 
  
要求： 
判断一个整数是否是回文数，不要使用额外的存储空间 
  
难度：简单 
  
分析： 
题目限制不允许使用额外的存储空间应指不允许使用O(n)的内存空间，O(1)的内存用于存储中间结果是可以接受的。于是考虑将该整型数反转，然后与原数字进行比较。 
注：没有看到有关负数是否可以是回文数的明确结论，例如
      
                                
      • 
                                
    • 画图板的基本实现
                                    15700786134
画图板
                                    
       要实现画图板的基本功能，除了在qq登陆界面中用到的组件和方法外，还需要添加鼠标监听器，和接口实现。 
首先，需要显示一个JFrame界面： 
public class DrameFrame extends JFrame {              //显示
      
                                
      • 
                                
    • linux的ps命令
                                    被触发
linux
                                    
      Linux中的ps命令是Process Status的缩写。ps命令用来列出系统中当前运行的那些进程。ps命令列出的是当前那些进程的快照，就是执行ps命令的那个时刻的那些进程，如果想要动态的显示进程信息，就可以使用top命令。 
要对进程进行监测和控制，首先必须要了解当前进程的情况，也就是需要查看当前进程，而 ps 命令就是最基本同时也是非常强大的进程查看命令。使用该命令可以确定有哪些进程正在运行
      
                                
      • 
                                
    • Android 音乐播放器 下一曲 连续跳几首歌
                                    肆无忌惮_
android
                                    
      最近在写安卓音乐播放器的时候遇到个问题。在MediaPlayer播放结束时会回调 
player.setOnCompletionListener(new OnCompletionListener() {

			@Override
			public void onCompletion(MediaPlayer mp) {
				mp.reset();
				Log.i("H
      
                                
      • 
                                
    • java导出txt文件的例子
                                    知了ing
javaservlet
                                    
      代码很简单就一个servlet,如下： 
 
package com.eastcom.servlet;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.URLEncoder;
import java.sql.Connection;
import java.sql.Resu
      
                                
      • 
                                
    • Scala stack试玩, 提高第三方依赖下载速度
                                    矮蛋蛋
scalasbt
                                    
      原文地址： 
http://segmentfault.com/a/1190000002894524 
sbt下载速度实在是惨不忍睹, 需要做些配置优化 
 
下载typesafe离线包, 保存为ivy本地库 
 
wget http://downloads.typesafe.com/typesafe-activator/1.3.4/typesafe-activator-1.3.4.zip 
解压r
      
                                
      • 
                                
    • phantomjs安装(linux，附带环境变量设置) ，以及casperjs安装。
                                    alleni123
linuxspider
                                    
      1. 首先从官网 
http://phantomjs.org/下载phantomjs压缩包，解压缩到/root/phantomjs文件夹。 
 
2. 安装依赖 
 
sudo yum install fontconfig freetype libfreetype.so.6 libfontconfig.so.1 libstdc++.so.6 
 
3. 配置环境变量 
vi /etc/profil
      
                                
      • 
                                
    • JAVA IO FileInputStream和FileOutputStream，字节流的打包输出
                                    百合不是茶
java核心思想JAVA IO操作字节流
                                    
      在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流 
1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流 
  
类 FileInputStream
      
                                
      • 
                                
    • Spring基础实例（依赖注入和控制反转）
                                    bijian1013
spring
                                    
      前提条件：在http://www.springsource.org/download网站上下载Spring框架，并将spring.jar、log4j-1.2.15.jar、commons-logging.jar加载至工程1.武器接口 
package com.bijian.spring.base3;

public interface Weapon {

   
    void kil
      
                                
      • 
                                
    • HR看重的十大技能
                                    bijian1013
提升能力HR成长
                                    
          一个人掌握何种技能取决于他的兴趣、能力和聪明程度，也取决于他所能支配的资源以及制定的事业目标，拥有过硬技能的人有更多的工作机会。但是，由于经济发展前景不确定，掌握对你的事业有所帮助的技能显得尤为重要。以下是最受雇主欢迎的十种技能。 　　一、解决问题的能力 　　每天，我们都要在生活和工作中解决一些综合性的问题。那些能够发现问题、解决问题并迅速作出有效决
      
                                
      • 
                                
    • 【Thrift一】Thrift编译安装
                                    bit1129
thrift
                                    
      什么是Thrift 
The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and s
      
                                
      • 
                                
    • 【Avro三】Hadoop MapReduce读写Avro文件
                                    bit1129
mapreduce
                                    
      Avro是Doug Cutting(此人绝对是神一般的存在）牵头开发的。 开发之初就是围绕着完善Hadoop生态系统的数据处理而开展的（使用Avro作为Hadoop MapReduce需要处理数据序列化和反序列化的场景）,因此Hadoop MapReduce集成Avro也就是自然而然的事情。 
这个例子是一个简单的Hadoop MapReduce读取Avro格式的源文件进行计数统计，然后将计算结果
      
                                
      • 
                                
    • nginx定制500，502，503，504页面
                                    ronin47
nginx　错误显示
                                    
      server {
     listen 80;
     error_page  500/500.html;
     error_page  502/502.html;
     error_page  503/503.html;
     error_page  504/504.html;

     location /test {return502;}} 
配置很简单，和配
      
                                
      • 
                                
    • java-1.二叉查找树转为双向链表
                                    bylijinnan
二叉查找树
                                    
      
import java.util.ArrayList;
import java.util.List;


public class BSTreeToLinkedList {
	
	/*
把二元查找树转变成排序的双向链表
题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
10
/ \
6 14
/ \ 
      
                                
      • 
                                
    • Netty源码学习-HTTP-tunnel
                                    bylijinnan
javanetty
                                    
      Netty关于HTTP tunnel的说明： 
 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/socket/http/package-summary.html#package_description 
 
这个说明有点太简略了 
 
一个完整的例子在这里： 
 
https://github.com/bylijinnan
      
                                
      • 
                                
    • JSONUtil.serialize(map)和JSON.toJSONString(map)的区别
                                    coder_xpf
jqueryjsonmapval()
                                    
       JSONUtil.serialize(map)和JSON.toJSONString(map)的区别 
  
数据库查询出来的map有一个字段为空 
  
通过System.out.println()输出  JSONUtil.serialize(map)： {"one":"1","two":"nul
      
                                
      • 
                                
    • Hibernate缓存总结
                                    cuishikuan
开源sshjavawebhibernate缓存三大框架
                                    
      一、为什么要用Hibernate缓存？ 
Hibernate是一个持久层框架，经常访问物理数据库。 
为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。 
缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。 
  
二、Hibernate缓存原理是怎样的？ 
Hibernate缓存包括两大类：Hib
      
                                
      • 
                                
    • CentOs6
                                    dalan_123
centos
                                    
      首先su - 切换到root下面1、首先要先安装GCC GCC-C++ Openssl等以来模块：yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel2、再安装ncurses模块yum -y install ncurses-develyum install ncurses-devel3、下载Erang
      
                                
      • 
                                
    • 10款用 jquery 实现滚动条至页面底端自动加载数据效果
                                    dcj3sjt126com
JavaScript
                                    
        
无限滚动自动翻页可以说是web2.0时代的一项堪称伟大的技术，它让我们在浏览页面的时候只需要把滚动条拉到网页底部就能自动显示下一页的结果，改变了一直以来只能通过点击下一页来翻页这种常规做法。 
无限滚动自动翻页技术的鼻祖是微博的先驱：推特(twitter)，后来必应图片搜索、谷歌图片搜索、google reader、箱包批发网等纷纷抄袭了这一项技术，于是靠滚动浏览器滚动条
      
                                
      • 
                                
    • ImageButton去边框&Button或者ImageButton的背景透明
                                    dcj3sjt126com
imagebutton
                                    
      在ImageButton中载入图片后，很多人会觉得有图片周围的白边会影响到美观，其实解决这个问题有两种方法 
一种方法是将ImageButton的背景改为所需要的图片。如：android:background="@drawable/XXX" 
第二种方法就是将ImageButton背景改为透明，这个方法更常用 
在XML里； 
   <ImageBut
      
                                
      • 
                                
    • JSP之c:foreach
                                    eksliang
jspforearch
                                    
      原文出自：http://www.cnblogs.com/draem0507/archive/2012/09/24/2699745.html 
<c:forEach>标签用于通用数据循环，它有以下属性    属 性 描 述 是否必须 缺省值   items 进行循环的项目 否 无   begin 开始条件 否 0   end 结束条件 否 集合中的最后一个项目   step 步长 否 1
      
                                
      • 
                                
    • Android实现主动连接蓝牙耳机
                                    gqdy365
android
                                    
      在Android程序中可以实现自动扫描蓝牙、配对蓝牙、建立数据通道。蓝牙分不同类型，这篇文字只讨论如何与蓝牙耳机连接。 
大致可以分三步： 
 
一、扫描蓝牙设备： 
1、注册并监听广播： 
 

BluetoothAdapter.ACTION_DISCOVERY_STARTED
BluetoothDevice.ACTION_FOUND
BluetoothAdapter.ACTION_DIS
      
                                
      • 
                                
    • android学习轨迹之四：org.json.JSONException: No value for
                                    hyz301
json
                                    
      org.json.JSONException: No value for items  
在JSON解析中会遇到一种错误，很常见的错误 
  
06-21 12:19:08.714    2098-2127/com.jikexueyuan.secret I/System.out﹕ Result:{"status":1,"page":1,&
      
                                
      • 
                                
    • 干货分享：从零开始学编程 系列汇总
                                    justjavac
编程
                                    
      程序员总爱重新发明轮子，于是做了要给轮子汇总。 
 
  从零开始写个编译器吧系列 (知乎专栏)  
  从零开始写一个简单的操作系统 (伯乐在线)  
  从零开始写JavaScript框架 (图灵社区)  
  从零开始写jQuery框架 (蓝色理想 )  
  从零开始nodejs系列文章 (粉丝日志)  
  从零开始编写网络游戏 
      
                                
      • 
                                
    • jquery-autocomplete 使用手册
                                    macroli
jqueryAjax脚本
                                    
      jquery-autocomplete学习 
一、用前必备 
官方网站：http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/  
当前版本：1.1 
需要JQuery版本：1.2.6 
二、使用 
<script src="./jquery-1.3.2.js" type="text/ja
      
                                
      • 
                                
    • PLSQL-Developer或者Navicat等工具连接远程oracle数据库的详细配置以及数据库编码的修改
                                    超声波
oracleplsql
                                    
      　　在服务器上将Oracle安装好之后接下来要做的就是通过本地机器来远程连接服务器端的oracle数据库，常用的客户端连接工具就是PLSQL-Developer或者Navicat这些工具了。刚开始也是各种报错，什么TNS:no listener;TNS:lost connection;TNS:target hosts...花了一天的时间终于让PLSQL-Developer和Navicat等这些客户
      
                                
      • 
                                
    • 数据仓库数据模型之：极限存储--历史拉链表
                                    superlxw1234
极限存储数据仓库数据模型拉链历史表
                                    
      在数据仓库的数据模型设计过程中，经常会遇到这样的需求： 
 1. 数据量比较大; 2. 表中的部分字段会被update,如用户的地址，产品的描述信息，订单的状态等等; 3. 需要查看某一个时间点或者时间段的历史快照信息，比如，查看某一个订单在历史某一个时间点的状态，    比如，查看某一个用户在过去某一段时间内，更新过几次等等; 4. 变化的比例和频率不是很大，比如，总共有10
      
                                
      • 
                                
    • 10点睛Spring MVC4.1-全局异常处理
                                    wiselyman
spring mvc
                                    
      10.1 全局异常处理 
 
 使用@ControllerAdvice注解来实现全局异常处理; 
 使用@ControllerAdvice的属性缩小处理范围 
  
10.2 演示 
 
 演示控制器 
  
package com.wisely.web;

import org.springframework.stereotype.Controller;
import org.spring
      
                                
      •