singleZhang2010
singleZhang2010

Spring源码阅读----Spring IoC之finishBeanFactoryInitialization（续）很重要的getBean

概述

前文中介绍的finishBeanFactoryInitialization方法是IOC的核心，其中的getBean方法还没有讲解到，在这里继续展开解析。我们阅读源码时，要抓主次，先按主线下来，然后在主线里做支路的标记，等主线阅读完后，再回顾支路的标记慢慢进去展开，这样避免引起“"迷路现象"，在源码中兜转一回不明白所以然。
在前文中，我们主要关注的是finishBeanFactoryInitialization里的preInstantiateSingletons方法，实例化所有剩余的非懒加载单例 bean，那如何实例化的呢？这得用到getBean这个方法。

getBean

AbstractBeanFactory类中的getBean方法,这里边有好几个getBean方法，我们主要看第一个用到的，源码如下:

    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

doGetBean是主要做事的方法,那么多getBean方法只是给外部提供一个调用接口,查看doGetBean的源码:

    /**
     * Return an instance, which may be shared or independent, of the specified bean.
     */
    @SuppressWarnings("unchecked")
    protected  T doGetBean(final String name, @Nullable final Class requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        //注释1. 获取 bean 名称，如果需要，去掉引用前缀（例如修饰符），还有将别名转换成最终 beanName
        final String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        // 注释2. 检查缓存中或者实例工厂是否有对应的实例或者从 singletonFactories 中的 ObjectFactory 中获取
        Object sharedInstance = getSingleton(beanName);

        // 注释3. 如果缓存中存在该beanName的实例
        if (sharedInstance != null && args == null) {
            if (logger.isTraceEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            // 注释3-1. 返回对应的实例，普通的bean返回
            // 对 FactoryBean 的特殊处理，是返回指定方法返回的实例
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {
            // 注释4. 如果缓存中不存在该beanName的实例  
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            // 注释4-1. 循环依赖校验,假设我们在一个循环引用中，我们之前已经创建了这个bean实例，则会抛出错误：循环依赖
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // Check if bean definition exists in this factory.
            // 注释4-2. 获取parentBeanFactory
            BeanFactory parentBeanFactory = getParentBeanFactory();

            // 注释4-2-1. 如果parentBeanFactory存在，并且beanName在当前BeanFactory不存在Bean定义，则尝试从parentBeanFactory中获取bean实例
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.将别名解析成真正的beanName
                String nameToLookup = originalBeanName(name);

                //通过parentBeanFactory获取bean实例
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                            nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
                    return (T) parentBeanFactory.getBean(nameToLookup);
                }
            }

            // 注释4-2-2. 如果不是仅仅做类型检查则是创建 bean，这里要将beanName放到alreadyCreated缓存
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            try {
                // 注释5. 根据beanName重新获取MergedBeanDefinition
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

                // 检查MergedBeanDefinition
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.
                // 注释6. 保证当前 bean 所依赖的bean的实例化，
                String[] dependsOn = mbd.getDependsOn();

                // 如果存在依赖则需要递归实例化依赖的 bean
                if (dependsOn != null) {
                    for (String dep : dependsOn) {

                        // 检查循环依赖报错~
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        // 将dep和beanName的依赖关系注册到缓存中
                        registerDependentBean(dep, beanName);
                        try {
                            // 获取dep对应的bean实例，如果dep还没有创建bean实例，则创建dep的bean实例
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }

                // Create bean instance. 创建 bean 实例
                // 注释7. singleton 单例模式（最常使用）
                if (mbd.isSingleton()) {
                    // 注释7-1.  scope为singleton的bean创建
                    //ObjectFactory为函数式接口,lambda表达式重写了getObject方法
                    sharedInstance = getSingleton(beanName, () -> {
                        try {

                            //注释7-1-1. 创建Bean实例
                            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;
                        }
                    });

                    //注释7-1-2.返回beanName对应的实例对象
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
                //注释7-2. scope为prototype的bean创建
                else if (mbd.isPrototype()) {
                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {

                        //注释7-2-1. 创建实例前的操作
                        beforePrototypeCreation(beanName);

                        //注释7-2-2.  创建Bean实例
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        //注释7-2-3.创建实例后的操作
                        afterPrototypeCreation(beanName);
                    }

                    //注释7-2-4.返回beanName对应的实例对象
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }
                //注释7-3. 其他scope的bean创建
                else {
                    //注释7-3-1. 获取scopeName，根据scopeName，从缓存拿到scope实例
                    String scopeName = mbd.getScope();
                    final Scope scope = this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
                    try {

                        //注释7-3-2. 其他scope的bean创建,新建了一个ObjectFactory
                        //ObjectFactory为函数式接口,lambda表达式重写了getObject方法
                        Object scopedInstance = scope.get(beanName, () -> {
                            //创建实例前的操作
                            beforePrototypeCreation(beanName);
                            try {
                                //创建bean实例
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                //创建实例后的操作
                                afterPrototypeCreation(beanName);
                            }
                        });
                        //返回beanName对应的实例对象
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) {
                        throw new BeanCreationException(beanName,
                                "Scope '" + scopeName + "' is not active for the current thread; consider " +
                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                                ex);
                    }
                }
            }
            catch (BeansException ex) {
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
        }

        // Check if required type matches the type of the actual bean instance.
        // 检查需要的类型是否符合 bean 的实际类型
        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                //类型不对，则尝试转换bean类型
                T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                }
                return convertedBean;
            }
            catch (TypeMismatchException ex) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Failed to convert bean '" + name + "' to required type '" +
                            ClassUtils.getQualifiedName(requiredType) + "'", ex);
                }
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        }

        //返回创建出来的bean实例对象
        return (T) bean;
    }

跟着注释走一遍，理解完其执行过程后，进入源码解析。

注释2.检查缓存中或者实例工厂是否有对应的实例或者从 singletonFactories 中的 ObjectFactory 中获取。在前文中对getSingleton这个方法解析过一次，里边使用了三级缓存的概念，可以回顾一下。
注释3-1. 返回对应的实例(见源码解析1)
注释4-2 通过parentBeanFactory 获取bean实例
注释4-2-2 判断如果不是仅仅做类型检查则是创建 bean，这里要将beanName放到alreadyCreated缓存(见源码解析2)
注释5. 获取MergedBeanDefinition,参考前文中的getMergedLocalBeanDefinition方法解析
注释6. 保证当前 bean 所依赖的bean的实例化，isDependent方法来检查循环依赖，registerDependentBean方法为记录beanName所对应的bean和所依赖的ben(dep)之间的依赖关系，注册到缓存中。(见源码解析3)
注释7. 按scope不同进行创建 bean 实例
注释7-1. scope为singleton的bean创建,这里调用了getSingleton(String beanName, ObjectFactory singletonFactory)方法(见源码解析4)
注释7-1-1. 创建Bean实例,createBean方法(这个方法很重要，在下一篇详细解析)
注释7-3-2 创建prototype的bean实例前的操作beforePrototypeCreation方法、创建实例后的操作afterPrototypeCreation方法,可以点进去跟踪简单了解一下这个执行过程:主要是在进行 bean 实例的创建前，将 beanName 添加到 prototypesCurrentlyInCreation 缓存；bean 实例创建后，将 beanName 从 prototypesCurrentlyInCreation 缓存中移除。这边 prototypesCurrentlyInCreation 存放的类型为 Object，在只有一个 beanName 的时候，直接存该 beanName，也就是 String 类型；当有多个 beanName 时，转成 Set 来存放。

【源码解析1】 获取 beanName 对应的实例对象：AbstractBeanFactory类中的getObjectForBeanInstance方法:

protected Object getObjectForBeanInstance(
            Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

        // Don't let calling code try to dereference the factory if the bean isn't a factory.
        // 查看isFactoryDereference可知道，这里判断的是 beanName 前缀是否是& 符号
        if (BeanFactoryUtils.isFactoryDereference(name)) {

            //如果是NullBean类型，直接返回
            if (beanInstance instanceof NullBean) {
                return beanInstance;
            }

            // 如果不是空 bean，又不是工厂 bean，报错
            if (!(beanInstance instanceof FactoryBean)) {
                throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
            }
        }

        // Now we have the bean instance, which may be a normal bean or a FactoryBean.
        // If it's a FactoryBean, we use it to create a bean instance, unless the
        // caller actually wants a reference to the factory.

            // 如果beanInstance不是FactoryBean（也就是普通bean），则直接返回beanInstance
            // 如果beanInstance是FactoryBean，并且name以“&”为前缀，则直接返回beanInstance（以“&”为前缀代表想获取的是FactoryBean本身）
        if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
            return beanInstance;
        }

        // 加载工厂 bean
        // 从上面排除信息可以知道，这里开始beanInstance是FactoryBean，但name不带有“&”前缀，表示想要获取的是FactoryBean创建的对象实例
        Object object = null;
        if (mbd == null) {
            // 如果mbd为空,先从缓存factoryBeanObjectCache中获取
            object = getCachedObjectForFactoryBean(beanName);
        }

        if (object == null) {
            // Return bean instance from factory.
            // 到了这一步，很确定是工厂 bean 类型了,类型强转
            FactoryBean factory = (FactoryBean) beanInstance;

            // Caches object obtained from FactoryBean if it is a singleton.
            // mbd为空，但是该bean的BeanDefinition在缓存中存在，则获取该bean的MergedBeanDefinitio
            if (mbd == null && containsBeanDefinition(beanName)) {
                mbd = getMergedLocalBeanDefinition(beanName);
            }

            // 判断mbd 是否是合成的BeanDefinition
            boolean synthetic = (mbd != null && mbd.isSynthetic());

            //注释1. 通过 getObjectFromFactoryBean方法获取对象实例
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    }

FactoryBean 前文中已经介绍过其定义了，是一种特殊的bean即工厂 bean，可以自己创建 bean 实例。
这里主要继续解析getObjectFromFactoryBean方法，获取对象实例(见源码解析1-1)

【源码解析1-1】 FactoryBeanRegistrySupport类中，从 FactoryBean 获取对象实例:getObjectFromFactoryBean

protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {

        //factoryBean如果是单例，并且已经存在于单例对象缓存中
        if (factory.isSingleton() && containsSingleton(beanName)) {

            //加锁操作
            synchronized (getSingletonMutex()) {

                //获取缓存
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {

                    // 注释1. 缓存不存在,通过factoryBean获取beanName实例对象
                    object = doGetObjectFromFactoryBean(factory, beanName);

                    // Only post-process and store if not put there already during getObject() call above
                    // (e.g. because of circular reference processing triggered by custom getBean calls)
                    //获取缓存
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {

                        //如果该beanName已经在缓存中存在，则将object替换成缓存中的alreadyThere
                        object = alreadyThere;
                    }
                    else {
                        if (shouldPostProcess) {

                            //该beanName被标记了属于正在创建的bean，存在于Set singletonsCurrentlyInCreation中
                            //则直接返回该实例对象
                            if (isSingletonCurrentlyInCreation(beanName)) {
                                // Temporarily return non-post-processed object, not storing it yet..
                                return object;
                            }
                            // 创建单例前的前置操作,校验下存不存在，不存在抛异常
                            beforeSingletonCreation(beanName);

                            try {
                                //注释2. 对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法
                                object = postProcessObjectFromFactoryBean(object, beanName);
                            }
                            catch (Throwable ex) {
                                throw new BeanCreationException(beanName,
                                        "Post-processing of FactoryBean's singleton object failed", ex);
                            }
                            finally {
                                // 创建单例后的后置操作，校验下存不存在，不存在抛异常
                                afterSingletonCreation(beanName);
                            }
                        }
                        if (containsSingleton(beanName)) {
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }
                return object;
            }
        }
        else {
            //factoryBean不是单例的情况下，通过factoryBean获取beanName实例对象
            Object object = doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                    // 对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                }
            }
            //返回object实例对象
            return object;
        }
    }

这个方法执行流程看下来，真正做事的得看doGetObjectFromFactoryBean这个方法。
注释1. 缓存不存在,通过factoryBean获取beanName实例对象,doGetObjectFromFactoryBean(见源码解析1-2)
注释2. 对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法,postProcessObjectFromFactoryBean(见源码解析1-3)

【源码解析1-2】 通过FactoryBean来获取到对象实例 : doGetObjectFromFactoryBean

private Object doGetObjectFromFactoryBean(final FactoryBean factory, final String beanName)
            throws BeanCreationException {

        Object object;
        try {
            //系统安全管理验证
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = getAccessControlContext();
                try {
                    //调用FactoryBean的getObject方法获取bean对象实例
                    object = AccessController.doPrivileged((PrivilegedExceptionAction) factory::getObject, acc);
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                //不作系统安全管理验证，调用FactoryBean的getObject方法获取bean对象实例
                object = factory.getObject();
            }
        }
        catch (FactoryBeanNotInitializedException ex) {
            throw new BeanCurrentlyInCreationException(beanName, ex.toString());
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
        }

        // Do not accept a null value for a FactoryBean that's not fully
        // initialized yet: Many FactoryBeans just return null then.
        if (object == null) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                //getObject返回的是空值，并且该beanName正在初始化中，则直接抛异常
                throw new BeanCurrentlyInCreationException(
                        beanName, "FactoryBean which is currently in creation returned null from getObject");
            }
            //创建一个新的NullBean对象
            object = new NullBean();
        }
            //返回创建好的bean对象实例
        return object;
    }
 
 
这里主要就是通过factory bean 的 getObject方法来获取对象。
 
 
【源码解析1-3】 子类AbstractAutowireCapableBeanFactory postProcessObjectFromFactoryBean，重写了父类FactoryBeanRegistrySupport里的方法:
 
 
    @Override
    protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
              //
        return applyBeanPostProcessorsAfterInitialization(object, beanName);
    }

    @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;

        //遍历所有注册的BeanPostProcessor实现类，调用postProcessAfterInitialization方法
        for (BeanPostProcessor processor : getBeanPostProcessors()) {

            //在bean初始化后，调用postProcessAfterInitialization方法
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                //如果返回null，则直接返回结果
                return result;
            }
            //有值则直接返回
            result = current;
        }
        return result;
    }

 
 
我们创建的beanFactory为DefaultListableBeanFactory类型，这边走的是 AbstractAutowireCapableBeanFactory 里的方法，它为DefaultListableBeanFactory父类，FactoryBeanRegistrySupport的子类，@Override重写父类FactoryBeanRegistrySupport的postProcessObjectFromFactoryBean方法。
 前面的registerBeanPostProcessors已经帮我们注册了各类BeanPostProcessors，它会再bean实例化后，初始化阶段执行被执行其接口的方法。
 
 
【源码解析2】 将beanName放到alreadyCreated缓存 ： markBeanAsCreated方法
 
 
    protected void markBeanAsCreated(String beanName) {
        if (!this.alreadyCreated.contains(beanName)) {
            synchronized (this.mergedBeanDefinitions) {
                //如果alreadyCreated缓存中不包含beanName
                if (!this.alreadyCreated.contains(beanName)) {
                    // Let the bean definition get re-merged now that we're actually creating
                    // the bean... just in case some of its metadata changed in the meantime.
                    //将beanName的MergedBeanDefinition从mergedBeanDefinitions缓存中移除，在之后重新获取MergedBeanDefinition
                    clearMergedBeanDefinition(beanName);
                    //将beanName添加到alreadyCreated缓存中，代表该beanName的bean实例已经创建（或即将创建）
                    this.alreadyCreated.add(beanName);
                }
            }
        }
    }

 
 
alreadyCreated 是一个Set集合作为已经创建（或即将创建）的实例集合，
 这边会将 beanName 对应的 MergedBeanDefinition 移除，然后在之后的代码重新获取，主要是为了使用最新的 MergedBeanDefinition 来进行创建操作。
 
 
【源码解析3】 保证当前 bean 所依赖的bean的实例化
 检查循环依赖：来自DefaultSingletonBeanRegistry类中的 isDependent方法
 
 
    protected boolean isDependent(String beanName, String dependentBeanName) {
        synchronized (this.dependentBeanMap) {
            return isDependent(beanName, dependentBeanName, null);
        }
    }

    private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set alreadySeen) {

        if (alreadySeen != null && alreadySeen.contains(beanName)) {
            return false;
        }
        // 点开canonicalName方法可以看到将别名解析为真正的名称
        String canonicalName = canonicalName(beanName);

        //依赖canonicalName的beanName集合
        Set dependentBeans = this.dependentBeanMap.get(canonicalName);
        if (dependentBeans == null) {
            //如果dependentBeans为空，则两者必然还未确定依赖关系，返回fals
            return false;
        }
        if (dependentBeans.contains(dependentBeanName)) {
            //如果dependentBeans包含dependentBeanName，则表示两者已确定依赖关系，返回true
            return true;
        }

        //循环检查，即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的（即隔层依赖）
        for (String transitiveDependency : dependentBeans) {
            if (alreadySeen == null) {
                alreadySeen = new HashSet<>();
            }

            //已经检查过的添加到alreadySeen，避免重复检查
            alreadySeen.add(beanName);

            //隔层依赖检查
            if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
                return true;
            }
        }
        return false;
    }

 
 
registerDependentBean方法:记录beanName所对应的bean和所依赖的ben(dep)之间的依赖关系，注册到缓存中
 
 
    public void registerDependentBean(String beanName, String dependentBeanName) {
        //解析别名
        String canonicalName = canonicalName(beanName);

        //加锁操作
        synchronized (this.dependentBeanMap) {
            //如果依赖关系还没有注册，则将两者的关系注册到dependentBeanMap和dependenciesForBeanMap缓存
            Set dependentBeans =
                    this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
            if (!dependentBeans.add(dependentBeanName)) {
                return;
            }
        }

        //加锁操作
        synchronized (this.dependenciesForBeanMap) {
            //将canonicalName添加到dependentBeanName依赖的beanName集合中
            Set dependenciesForBean =
                    this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
            dependenciesForBean.add(canonicalName);
        }
    }

 
 
dependenciesForBeanMap:beanName 对应的 bean 依赖的所有 bean 的 beanName 集合，
 前面提到的dependentBeanMap 是所有依赖 beanName 对应的 bean 的 beanName 集合
 
 
【源码解析4】 前文介绍过getSingleton(String beanName)方法，这里调用的是 DefaultSingletonBeanRegistry类中的getSingleton(String beanName, ObjectFactory singletonFactory)方法
 
 
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        // 注释 全局变量，加锁
        synchronized (this.singletonObjects) {
            // 首先检查beanName对应的bean实例是否在缓存中存在
            Object singletonObject = this.singletonObjects.get(beanName);

            //如果不存在,则进入创建操作
            if (singletonObject == null) {
                //当bean factory的单例处于destruction状态时，不允许进行单例bean创建，抛出异常
                if (this.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(beanName,
                            "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                            "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }

                if (logger.isDebugEnabled()) {
                    logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }

                // 注释1-1. 创建单例前的操作，校验是否 beanName 是否有别的线程在初始化，并加入初始化状态中
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                try {
                    // 执行singletonFactory的getObject方法获取bean实例
                    //实际执行的是 createBean 方法
                    singletonObject = singletonFactory.getObject();

                    //标记为新的单例对象
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
                    // Has the singleton object implicitly appeared in the meantime ->
                    // if yes, proceed with it since the exception indicates that state.
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw ex;
                    }
                }
                catch (BeanCreationException ex) {
                    if (recordSuppressedExceptions) {
                        for (Exception suppressedException : this.suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    //注释1-2.  创建单例后的操作，移除初始化状态
                    afterSingletonCreation(beanName);
                }
                if (newSingleton) {
                    // 注释2. 如果是新的单例对象,加入缓存
                    //singletonObjects、registeredSingletons
                    addSingleton(beanName, singletonObject);
                }
            }

            // 返回单例对象
            return singletonObject;
        }
    }

 
 
这个方法传入的第二个参数为lambda表达式的匿名函数,ObjectFactory为函数式接口，所以singletonFactory的getObject方法会触发匿名函数里的createBean方法。
 注释1-1、1-2. 创建单例前的操作、创建单例后的操作，出现在创建单例的前后(见源码解析5)
 注释2. 如果是新的单例对象，将 beanName 和对应的单例对象添加到缓存中:addSingleton方法
 
 
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 1.添加到单例对象缓存
        this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
        // 2.将单例工厂缓存移除（已经不需要）
        this.singletonFactories.remove(beanName);
        // 3.将早期单例对象缓存移除（已经不需要）
        this.earlySingletonObjects.remove(beanName);
        // 4.添加到已经注册的单例对象缓存
        this.registeredSingletons.add(beanName);
    }
}

 
 
这个方法是比较重要的，多关注一下，乍一看就是对各类Map的操作，前文我们已经了解过singletonObjects、earlySingletonObjects、singletonFactories 构成了三级缓存的概念，这里是把创建好的实例对象移动到一级缓存singletonObjects 和注册的单例对象缓存registeredSingletons中，移除掉二级、三级缓存。一级缓存中的是完全态创建的实例对象，二级、三级是创建中的半成品实例对象。
 
 
【源码解析5】
 
 
protected void beforeSingletonCreation(String beanName) {
    // 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
    // 则将beanName加入到正在创建bean的缓存中（Set），如果beanName已经存在于该缓存，会返回false抛出异常（这种情况出现在构造器的循环依赖）
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}
 
protected void afterSingletonCreation(String beanName) {
    // 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
    // 则将beanName从正在创建bean的缓存中（Set）移除，如果beanName不存在于该缓存，会返回false抛出异常
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }


 
 
inCreationCheckExclusions 是要在创建检查排除掉的 beanName 集合，正常为空，可以不管。这边主要是引入了 singletonsCurrentlyInCreation 缓存：当前正在创建的 bean 的 beanName 集合。在 beforeSingletonCreation 方法中，通过添加 beanName 到该缓存，可以预防出现构造器循环依赖的情况。
 
 
为什么这里无法解决构造器循环依赖？
 
 
我们之前在前文提过，getSingleton 方法是解决循环引用的核心代码。有一句话：“我们先用构造函数创建一个 “不完整” 的 bean 实例”，从这句话可以看出，构造器循环依赖是无法解决的，因为当构造器出现循环依赖，我们连 “不完整” 的 bean 实例都构建不出来。Spring 能解决这类循环依赖的方案有：通过 setter 注入的循环依赖、通过属性注入的循环依赖,使用@lazy注解，使用@PostConstruct等，优先建议使用setter注入来解决。
 
 
总结
 
 
这里介绍了bean实例化部分的getBean方法，包括先从缓存中获取实例(getSingleton)、 FactoryBean 的 bean 创建(getObjectForBeanInstance)、实例化自己的依赖即dependOn变量(递归调用getBean来创建实例)、创建 bean 实例(createBean)，以及创建前后一些标记等，createBean方法也是个很重要的方法，下一文中详细介绍它。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring源码阅读----Spring IoC之finishBeanFactoryInitialization（续）很重要的getBean)

        

            

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

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

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

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

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

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

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

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

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

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

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

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

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

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

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

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

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 瑶池防线
                        谜影梦蝶

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

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                                
  • 异常的核心类Throwable
                                    无量
java源码异常处理exception
                                    
    java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类 里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy 
 
 
 
package com.natsu;



    
                                
    • 
                                
  • mongoDB 游标（cursor） 实现分页 迭代
                                    开窍的石头
mongodb
                                    
    上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询 
 
     如何声明一个游标 
       var mycursor = db.user.find({_id:{$lte:5}}); 
      迭代显示游标数
    
                                
    • 
                                
  • MySQL数据库INNODB 表损坏修复处理过程
                                    0624chenhong
tomcatmysql
                                    
    最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
    
                                
    • 
                                
  • 剖析如何与设计人员沟通
                                    不懂事的小屁孩
工作
                                    
    最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。 
 
那应该如何与设计人员沟通呢？ 
 
我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
    
                                
    • 
                                
  • qq空间刷评论工具
                                    换个号韩国红果果
JavaScript
                                    
    

var a=document.getElementsByClassName('textinput');
					var b=[];
					for(var m=0;m<a.length;m++){
						if(a[m].getAttribute('placeholder')!=null)
							b.push(a[m])
					}
					var l
    
                                
    • 
                                
  • S2SH整合之session
                                    灵静志远
springAOPstrutssession
                                    
    错误信息： 
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
    
                                
    • 
                                
  • xmp标签
                                    a-john
标签
                                    
    今天在处理数据的显示上遇到一个问题： 
var html = '<li><div class="pl-nr"><span class="user-name">' + user
           + '</span>' + text + '</div></li>';
ulComme
    
                                
    • 
                                
  • Ajax的常用技巧（2）---实现Web页面中的级联菜单
                                    aijuans
Ajax
                                    
    在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。 在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
    
                                
    • 
                                
  • 天-安-门，好高
                                    atongyeye
情感
                                    
        我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。 
 
    晚上躺在床上一个人想了很久，很久。 
   
    我生在农
    
                                
    • 
                                
  • android 动画
                                    百合不是茶
android透明度平移缩放旋转
                                    
    android的动画有两种  tween动画和Frame动画 
  
tween动画;,透明度,缩放,旋转,平移效果 
  
Animation   动画 
AlphaAnimation 渐变透明度 
RotateAnimation 画面旋转 
ScaleAnimation 渐变尺寸缩放 
TranslateAnimation 位置移动 
Animation
    
                                
    • 
                                
  • 查看本机网络信息的cmd脚本
                                    bijian1013
cmd
                                    
    @echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt"
@echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt"
@echo ___________________>>"%userprofile%\
    
                                
    • 
                                
  • plsql 清除登录过的用户
                                    征客丶
plsql
                                    
    tools---preferences----logon history---history  把你想要删除的删除 
 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一起进步。 
email ： binary_spac
    
                                
    • 
                                
  • 【Pig一】Pig入门
                                    bit1129
pig
                                    
    Pig安装 
1.下载pig 
  
wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz 
  
2. 解压配置环境变量 
  
   如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量 
  
expor
    
                                
    • 
                                
  • Java 线程同步几种方式
                                    BlueSkator
volatilesynchronizedThredLocalReenTranLockConcurrent
                                    
    为何要使用同步？       java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），        将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，        从而保证了该变量的唯一性和准确性。    1.同步方法&
    
                                
    • 
                                
  • StringUtils判断字符串是否为空的方法（转帖）
                                    BreakingBad
nullStringUtils“”
                                    
    转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html 
  
public static boolean isEmpty(String str)      
　　判断某字符串是否为空，为空的标准是 str== 
null  
或 str.length()== 
0    
    
                                
    • 
                                
  • 编程之美-分层遍历二叉树
                                    bylijinnan
java数据结构算法编程之美
                                    
    

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LevelTraverseBinaryTree {

    /**
     * 编程之美 分层遍历二叉树
     * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
    
                                
    • 
                                
  • jquery取值和ajax提交复习记录
                                    chengxuyuancsdn
jquery取值ajax提交
                                    
    
// 取值
	// alert($("input[name='username']").val());
	// alert($("input[name='password']").val());
	// alert($("input[name='sex']:checked").val());
	// alert($("
    
                                
    • 
                                
  • 推荐国产工作流引擎嵌入式公式语法解析器-IK Expression
                                    comsci
java应用服务器工作Excel嵌入式
                                    
    这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 
----------转帖--------------------------------------------------- 
 IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
    
                                
    • 
                                
  • 关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer
                                    daizj
spring
                                    
    1、PropertyPlaceholderConfigurer 
Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。 
 
基本的使用方法是：(1) 
 
<bean id="propertyConfigurerForWZ&q
    
                                
    • 
                                
  • 二叉树:二叉搜索树
                                    dieslrae
二叉树
                                    
        所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. 
 
tree代码: 
 

    
                                
    • 
                                
  • C语言字符串函数大全
                                    dcj3sjt126com
cfunction
                                    
    C语言字符串函数大全 
  
  
函数名: stpcpy 
功 能: 拷贝一个字符串到另一个 
用 法: char *stpcpy(char *destin, char *source); 
程序例: 
  
#include <stdio.h> 
#include <string.h> 
  
int main
    
                                
    • 
                                
  • 友盟统计页面技巧
                                    dcj3sjt126com
技巧
                                    
    在基类调用就可以了, 基类ViewController示例代码 
-(void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];

    
                                
    • 
                                
  • window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法
                                    flyvszhb
javajdk
                                    
    window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 
 
本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 
 安装jdk1.6前，执行java -version得到 
C:\Users\liuxiang2>java -version 
java version "1.7.0_21&quo
    
                                
    • 
                                
  • Java在创建子类对象的同时会不会创建父类对象
                                    happyqing
java创建子类对象父类对象
                                    
      
1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象， 
  
2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
    
                                
    • 
                                
  • 跟我学spring3 目录贴及电子书下载
                                    jinnianshilongnian
spring
                                    
      
  一、《跟我学spring3》电子书下载地址： 
《跟我学spring3》  （1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf   
  
跟我学spring3系列 word原版 下载 
  
  二、
源代码下载  
最新依
    
                                
    • 
                                
  • 第12章 Ajax（上）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BI and EIM 4.0 at a glance
                                    blueoxygen
BO
                                    
    http://www.sap.com/corporate-en/press.epx?PressID=14787 
  
有机会研究下EIM家族的两个新产品~~~~ 
  
New features of the 4.0 releases of BI and EIM solutions include:  
 
  Real-time in-memory computing – 
    
                                
    • 
                                
  • Java线程中yield与join方法的区别
                                    tomcat_oracle
java
                                    
    长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 
&nb
    
                                
    • 
                                
  • android Manifest.xml选项
                                    阿尔萨斯
Manifest
                                    
    结构 
继承关系 
public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 
内部类 
 
 
 class Manifest.permission权限 
 class Manifest.permission_group权限组 
 构造函数 
 
public Manifest () 详细  androi
    
                                
    • 
                                
  • Oracle实现类split函数的方
                                    zhaoshijie
oracle
                                    
    关键字：Oracle实现类split函数的方 
项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 
 
CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); 
 
cr
    
                                
    •