wanshibugong119
wanshibugong119

spring容器的本质（下）

5.8对象实例化

到了这一步，我们已经完整的把所有xml配置文件里面定义的对象转化到BeanFactory里面的beanDefinitionMap，但是此时IOC容器还没开始实例化这些对象，接下来就是实例化的过程。回顾一下我们分析入口的refresh()方法，里面的finishBeanFactoryInitialization(beanFactory)就是对象的实例化过程，我们重点来分析这个方法的流程。

  • 完成对象实例化入口

    // AbstractApplicationContext.java 834

        protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {        // Initialize conversion service for this context.
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(new StringValueResolver() {                @Override
                public String resolveStringValue(String strVal) {                    return getEnvironment().resolvePlaceholders(strVal);
                }
            });
        }        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
         //JVM动态织入第三方模块
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }        // Stop using the temporary ClassLoader for type matching.
         //消除临时类加载器
        beanFactory.setTempClassLoader(null);        // Allow for caching all bean definition metadata, not expecting further changes.
         //冻结配置文件，避免重复读取
        beanFactory.freezeConfiguration();        // Instantiate all remaining (non-lazy-init) singletons.
         //实例化非懒加载对象
        beanFactory.preInstantiateSingletons();
    }

  • 单例对象预实例化

    //DefaultListableBeanFactory.java 728

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

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

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
             //合并具有父子关系的对象
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {//通常不是工厂bean
                    final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
                            @Override
                            public Boolean run() {
                                return ((SmartFactoryBean) factory).isEagerInit();
                            }
                        }, getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
                else {
                    getBean(beanName);//进入实例化bean
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(new PrivilegedAction() {
                        @Override
                        public Object run() {
                            smartSingleton.afterSingletonsInstantiated();
                            return null;
                        }
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    } 
    
  • 实例化工厂里面定义的对象
    //AbstractBeanFactory.java 196
        public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }
    //AbstractBeanFactory.java 235
        protected  T doGetBean(            final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {        final String beanName = transformedBeanName(name);        //返回的实例化对象，等待赋值
        Object bean;        // Eagerly check singleton cache for manually registered singletons.
        //从目标MAP里面获取实例化对象,检查是否已经实例化过
        Object sharedInstance = getSingleton(beanName);        //如果存在则不需要再实例化,首次实例化为空，进入下个判断
        if (sharedInstance != null && args == null) {            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 = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }        else {            //判断该beanName是否被实例化为prototype或者被创建中，如果是则抛异常
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            if (isPrototypeCurrentlyInCreation(beanName)) {                throw new BeanCurrentlyInCreationException(beanName);
            }            //判断bean的定义是否存在工厂里面
            // Check if bean definition exists in this factory.
            BeanFactory parentBeanFactory = getParentBeanFactory();            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);                if (args != null) {                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }                else {                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }            //激动的说时刻到来，开始准备实例化bean了
            try {                //获取bean的定义对象
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);                //优先实例化所要依赖的对象
                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn();                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 + "'");
                        }
                        registerDependentBean(dep, beanName);                        try {
                            getBean(dep);
                        }                        catch (NoSuchBeanDefinitionException ex) {                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }                //创建单例对象
                // Create bean instance.
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory() {                        @Override
                        public Object getObject() throws BeansException {                            try {                                //开始创建对象
                                return createBean(beanName, mbd, args);
                            }                            catch (BeansException ex) {                                // Explicitly remove instance from singleton cache: It might have been put there
                                // eagerly by the creation process, to allow for circular reference resolution.
                                // Also remove any beans that received a temporary reference to the bean.
                                destroySingleton(beanName);                                throw ex;
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }                //同理创建prototype类型的对象，非单例，创建出来后不再维护生命周期
                else if (mbd.isPrototype()) {                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;                    try {
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }                //如果都不是以上两种类型，则需要在创建前后回调特殊操作
                else {
                    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 {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory() {                            @Override
                            public Object getObject() throws BeansException {
                                beforePrototypeCreation(beanName);                                try {                                    return createBean(beanName, mbd, args);
                                }                                finally {
                                    afterPrototypeCreation(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.
        if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {            try {                return getTypeConverter().convertIfNecessary(bean, requiredType);
            }            catch (TypeMismatchException ex) {                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to convert bean '" + name + "' to required type '" +
                            ClassUtils.getQualifiedName(requiredType) + "'", ex);
                }                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        }        return (T) bean;
    }
    //AbstractAutowireCapableBeanFactory.java 447
    @Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {   if (logger.isDebugEnabled()) {
      logger.debug("Creating instance of bean '" + beanName + "'");
   }
   RootBeanDefinition mbdToUse = mbd;    //确保对象对应的类被加载进内存
   // Make sure bean class is actually resolved at this point, and
   // clone the bean definition in case of a dynamically resolved Class
   // which cannot be stored in the shared merged bean definition.
   Class resolvedClass = resolveBeanClass(mbd, beanName);   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }   // Prepare method overrides.
   try {
      mbdToUse.prepareMethodOverrides();
   }   catch (BeanDefinitionValidationException ex) {      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
   }   try {      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      //为AOP做的钩子
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);      if (bean != null) {         return bean;
      }
   }   catch (Throwable ex) {      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
            "BeanPostProcessor before instantiation of bean failed", ex);
   }   //终于到了创建对象了，还有完没完啊。。。
   Object beanInstance = doCreateBean(beanName, mbdToUse, args);   if (logger.isDebugEnabled()) {
      logger.debug("Finished creating instance of bean '" + beanName + "'");
   }   return beanInstance;
}
    //AbstractAutowireCapableBeanFactory.java 504
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
      throws BeanCreationException {   // Instantiate the bean.
   BeanWrapper instanceWrapper = null;   if (mbd.isSingleton()) {      //从工厂bean缓存容器里面移除
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }   //为空说明不是工厂bean，可以直接创建对象
   if (instanceWrapper == null) {       //这一步是真正的创建对象，看来还没完没了啊。。。。
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }   //经过漫长的过程，我们终于得到我们心心念念的bean了，坑爹。。。
   final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
   Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
   mbd.resolvedTargetType = beanType;   // Allow post-processors to modify the merged bean definition.
   //创建完bean后的一些特殊操作
   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));   if (earlySingletonExposure) {      if (logger.isDebugEnabled()) {
         logger.debug("Eagerly caching bean '" + beanName +               "' to allow for resolving potential circular references");
      }
      addSingletonFactory(beanName, new ObjectFactory() {         @Override
         public Object getObject() throws BeansException {            return getEarlyBeanReference(beanName, mbd, bean);
         }
      });
   }   //该方法两大重头戏，上面createBeanInstance是创建对象，populateBean是初始化属性值
   // Initialize the bean instance.
   Object exposedObject = bean;   try {
      populateBean(beanName, mbd, instanceWrapper);      if (exposedObject != null) {
         exposedObject = initializeBean(beanName, exposedObject, mbd);
      }
   }   catch (Throwable ex) {      if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {         throw (BeanCreationException) ex;
      }      else {         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
      }
   }   if (earlySingletonExposure) {
      Object earlySingletonReference = getSingleton(beanName, false);      if (earlySingletonReference != null) {         if (exposedObject == bean) {
            exposedObject = earlySingletonReference;
         }         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            String[] dependentBeans = getDependentBeans(beanName);
            Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);            for (String dependentBean : dependentBeans) {               if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                  actualDependentBeans.add(dependentBean);
               }
            }            if (!actualDependentBeans.isEmpty()) {               throw new BeanCurrentlyInCreationException(beanName,                     "Bean with name '" + beanName + "' has been injected into other beans [" +
                     StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                     "] in its raw version as part of a circular reference, but has eventually been " +
                     "wrapped. This means that said other beans do not use the final version of the " +
                     "bean. This is often the result of over-eager type matching - consider using " +
                     "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
            }
         }
      }
   }   // Register bean as disposable.
   try {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }   catch (BeanDefinitionValidationException ex) {      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
   }   return exposedObject;
} 
    
  • 真正的bean实例化动作
    //AbstractAutowireCapableBeanFactory.java 1061
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {   //确保对象对应的类被加载了
   // Make sure bean class is actually resolved at this point.
   Class beanClass = resolveBeanClass(mbd, beanName);   if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
   }    //工厂方法实例化
   if (mbd.getFactoryMethodName() != null)  {      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }    //无参数构造方法实例化
   // Shortcut when re-creating the same bean...
   boolean resolved = false;   boolean autowireNecessary = false;   if (args == null) {      synchronized (mbd.constructorArgumentLock) {         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true;
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }   if (resolved) {      if (autowireNecessary) {         return autowireConstructor(beanName, mbd, null, null);
      }      else {         return instantiateBean(beanName, mbd);
      }
   }    //有入参的构造方法实例化
   // Need to determine the constructor...
   Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);   if (ctors != null ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {      return autowireConstructor(beanName, mbd, ctors, args);
   }    //我们选简单一点的无参数构造方法实例化
   // No special handling: simply use no-arg constructor.
   return instantiateBean(beanName, mbd);
}
    //AbstractAutowireCapableBeanFactory.java 1138
    protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {   try {
      Object beanInstance;      final BeanFactory parent = this;      if (System.getSecurityManager() != null) {
         beanInstance = AccessController.doPrivileged(new PrivilegedAction() {            @Override
            public Object run() {               //获取实例化策略，这会可是实实在在的实例化了
               return getInstantiationStrategy().instantiate(mbd, beanName, parent);
            }
         }, getAccessControlContext());
      }      else {
         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);      return bw;
   }   catch (Throwable ex) {      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
   }
}
    //SimpleInstantiationStrategy.java 59
    @Overridepublic Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {   // Don't override the class with CGLIB if no overrides.
   if (bd.getMethodOverrides().isEmpty()) {
      Constructor constructorToUse;      synchronized (bd.constructorArgumentLock) {
         constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;         if (constructorToUse == null) {            final Class clazz = bd.getBeanClass();            if (clazz.isInterface()) {               throw new BeanInstantiationException(clazz, "Specified class is an interface");
            }            try {               if (System.getSecurityManager() != null) {
                  constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction>() {                     @Override
                     public Constructor run() throws Exception {                        return clazz.getDeclaredConstructor((Class[]) null);
                     }
                  });
               }               else {                  //构造方法反射实例化
                  constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
               }
               bd.resolvedConstructorOrFactoryMethod = constructorToUse;
            }            catch (Throwable ex) {               throw new BeanInstantiationException(clazz, "No default constructor found", ex);
            }
         }
      }      return BeanUtils.instantiateClass(constructorToUse);
   }   else {      // Must generate CGLIB subclass.
      return instantiateWithMethodInjection(bd, beanName, owner);
   }
}
    //BeanUtils.java 138
    public static  T instantiateClass(Constructor ctor, Object... args) throws BeanInstantiationException {
   Assert.notNull(ctor, "Constructor must not be null");   try {
      ReflectionUtils.makeAccessible(ctor);      //核心核心！终于重bean里面获取类，类的构造方法，然后反射new除了对象，好累。
      return ctor.newInstance(args);
   }   catch (InstantiationException ex) {      throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
   }   catch (IllegalAccessException ex) {      throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
   }   catch (IllegalArgumentException ex) {      throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
   }   catch (InvocationTargetException ex) {      throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
   }
}
     
    
   
    5.9对象属性初始化
     
   
       
    
    • 经过漫长漫长的过程，我们终于把配置文件里面定义的bean，千辛万苦的读取了对应的class，抽取出构造函数，然后通过反射new除了对象，但是此时的对象还是空空如也，需要我们把预设置的值初始化进去，这也是最后一步了
      //AbstractAutowireCapableBeanFactory.java 1207
      protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {   //获取所有的属性值
   PropertyValues pvs = mbd.getPropertyValues();   if (bw == null) {      if (!pvs.isEmpty()) {         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
      }      else {         // Skip property population phase for null instance.
         return;
      }
   }   // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
   // state of the bean before properties are set. This can be used, for example,
   // to support styles of field injection.
   boolean continueWithPropertyPopulation = true;   //出现BeanPostProcessors又是钩子，给出各种特殊操作
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {      for (BeanPostProcessor bp : getBeanPostProcessors()) {         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
               continueWithPropertyPopulation = false;               break;
            }
         }
      }
   }   if (!continueWithPropertyPopulation) {      return;
   }   if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);      // Add property values based on autowire by name if applicable.
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {          //通过name属性来装配
         autowireByName(beanName, mbd, bw, newPvs);
      }      // Add property values based on autowire by type if applicable.
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {         //通过type属性来装配
         autowireByType(beanName, mbd, bw, newPvs);
      }

      pvs = newPvs;
   }   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();   boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);   if (hasInstAwareBpps || needsDepCheck) {
      PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);      if (hasInstAwareBpps) {         for (BeanPostProcessor bp : getBeanPostProcessors()) {            if (bp instanceof InstantiationAwareBeanPostProcessor) {
               InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
               pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);               if (pvs == null) {                  return;
               }
            }
         }
      }      if (needsDepCheck) {
         checkDependencies(beanName, mbd, filteredPds, pvs);
      }
   }   //实际装配配置文件的属性
   applyPropertyValues(beanName, mbd, bw, pvs);
}
      •  
   
     
   
    到此，从阅读器读取xml配置文件，到加载到工厂的注册表，到实例化成对象，到最后的初始化对象属性，终于结束了。
     
   
    6.设计模式
     
   
    由于微信公众号字数限制，设计模式具体的代码就不贴出来了，只提供入口。
     
   
    6.1工厂模式
     
   
    意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
     
   
    主要解决：主要解决接口选择的问题。
     
   
    何时使用：我们明确地计划不同条件下创建不同实例时。
     
   
    如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
     
   
    关键代码：创建过程在其子类执行。
     
   
    优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
     
   
    缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
     
   
    应用：抽象Bean工厂类AbstractBeanFactory，很好的实现了改设计模式，createBean方法创建对象的过程放在具体的子类里面实现。
     
   
    //AbstractBeanFactory.java  1759
     
   
    6.2单例模式
     
   
    意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
     
   
    主要解决：一个全局使用的类频繁地创建与销毁。
     
   
    何时使用：当您想控制实例数目，节省系统资源的时候。
     
   
    如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
     
   
    关键代码：构造函数是私有的。
     
   
    优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。
     
   
    缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
     
   
    应用： spring容器读取bean定义后，根基bean是否为单例类型来实例化对象，如果存在则不再创建
     
   
    //AbstractBeanFactory.java  235
     
   
    6.3建造者模式
     
   
    意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
     
   
    主要解决：主要解决在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
     
   
    何时使用：一些基本部件不会变，而其组合经常变化的时候。
     
   
    如何解决：将变与不变分离开。
     
   
    关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
     
   
    优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
     
   
    缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
     
   
    应用实例： spring容器在构建bean的定义时需要从配置文件里面解析后登记到容器的注册表，BeanDefinitionBuilder扮演建造者的角色来设置BeanDefinition的值。
     
   
    6.4装饰器模式
     
   
    意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
     
   
    主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。
     
   
    何时使用：在不想增加很多子类的情况下扩展类。
     
   
    如何解决：将具体功能职责划分，同时继承装饰者模式。
     
   
    关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。
     
   
    优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
     
   
    缺点：多层装饰比较复杂。
     
   
    使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。
     
   
    注意事项：可代替继承。
     
   
    应用实例： 包装模式 AbstractAutowireCapableBeanFactory.java  504行   doCreateBean()   BeanWrapper
     
   
    6.5观察者模式
     
   
    意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
     
   
    主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。
     
   
    何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。
     
   
    如何解决：使用面向对象技术，可以将这种依赖关系弱化。
     
   
    关键代码：在抽象类里有一个 ArrayList 存放观察者们。
     
   
    优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。
     
   
    缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。
     
   
    使用场景：
     
   
       
    
    • 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
      •  
    
    • 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
      •  
    
    • 一个对象必须通知其他对象，而并不知道这些对象是谁。
      •  
    
    • 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。
      •  
   
     
   
    应用实例： 观察者模式ApplicationEventPublisher,ApplicationListener
     
   
    //AbstractApplicationContext.java 370
     
   
    6.6策略模式
     
   
    意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。
     
   
    主要解决：在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。
     
   
    何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。
     
   
    如何解决：将这些算法封装成一个一个的类，任意地替换。
     
   
    关键代码：实现同一个接口。
     
   
    优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。
     
   
    缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。
     
   
    使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。
     
   
    注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。
     
   
    应用实例： 策略模式AbstractAutowireCapableBeanFactory.java 1138行,方法instantiateBean()   getInstantiationStrategy()
     
   
    6.7代理模式
     
   
    代理模式  aop   ProxyFactoryBean.java
     
   
    暂略
     
   
    6.8适配器模式
     
   
    适配器 aop
     
   
    暂略
     
   
    6.9模板模式
     
   
    模板 Template Method  jdbcTemplate
     
   
    暂略
     
   
    7.思想
     
   
    IOC容器（Inversion of Control，缩写为IoC）也称为控制反转。这个词很多同学都很熟悉，但是真正要理解好并不是一件容易的事情。
    控制反转是代表一种思想，依赖注释是一种实现设计模式。
    控制反转是在以解耦为目标驱动而产生的一种思想，终极目标就是通过IOC容器提供中间商的作用，让对象之间的依赖不靠对象自身控制。
     
   
    7.1控制反转
     
   
    汽车发动机里面的齿轮大小不一，相互咬合着转动，协同工作。这个非常复杂的一套机械系统，其中任何一个齿轮发生故障都有可能导致发动机抛锚。对比我们软件设计过程遇到的就是深耦合的问题，随着软件复杂度的日益增加，我们迫切需要解决对象之间耦合过高的情形。
     
   
    spring容器的本质（下）_第1张图片
     
   
    软件专家Michael Mattson提出了IOC理论，也就是控制反转，它是一种面向对象编程中的一种设计原则，用来减低计算机代码之间的耦合度。其核心思想是：借助“第三方平台”实现具有依赖关系的对象之间的解耦。
     
   
    引入第三方平台后，对象的主动控制被剥夺，不再自主显式创建所要依赖的对象，而是被动的由第三方平台来控制，当执行到需要其他对象的时候，第三方平台会自动返回所需对象。这样的一种由主动创建到被动分配对象的方式，就叫做控制反转。这个第三方平台就是IOC容器，在它的眼里各个对象之间都是独立的存在，他们之间的依赖关系也只是被写到注册表里面，运行的时候回去检查依赖所需，按需分配，把对象“粘合”到容器里面。
     
   
    spring容器的本质（下）_第2张图片
     
   
    控制反转是一种思想，不止应用在软件设计中，现实生活中其实也是可以用得到的。比如电影院提供卖票服务，每增加一个渠道电影院就得新增人员与其对接，这样如果渠道多的话电影院就忙不过来，而且很容易出错。与其这样每次新增人员对接，电影院索性制定了对接标准，你们谁要来我这里拿电影票，就得按我的标准来。电影院不再需要每次都主动对接渠道，而是把控制权拿过来，自己制定标准，渠道商按照标准来，这也是控制反转的一种实践。
     
   
    7.2依赖注入
     
   
    依赖注入就是将实例变量传入到一个对象中去(Dependency injection means giving an object its instance variables)
    思想实现需要具体的步骤，依赖注入就是实现控制反转的方法论。
     
   
    最后容我举一个粗浅的例子，如果说spring容器的context是舞台，那么bean就是演员，spring的core就是剧本，让bean在舞台上享受了她们的人生（生命周期）。
     
   
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(spring容器的本质（下）)
    
        
    
            
    
                
      
                    
    • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
      很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在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
      
                    
      • 
                    
    • 瑶池防线
                        谜影梦蝶

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

                        
      爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
      
                    
      • 
                                
    • java杨辉三角
                                    3213213333332132
java基础
                                    
      
package com.algorithm;

/**
 * @Description 杨辉三角
 * @author FuJianyong
 * 2015-1-22上午10:10:59
 */
public class YangHui {
	public static void main(String[] args) {
		//初始化二维数组长度
		int[][] y
      
                                
      • 
                                
    • 《大话重构》之大布局的辛酸历史
                                    白糖_
重构
                                    
      《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。 
  
 
 背景 
 
        公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
      
                                
      • 
                                
    • 电驴链接在线视频播放源码
                                    dubinwei
源码电驴播放器视频ed2k
                                    
      本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： 
http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。 
项目源码： 
http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。 
项目源码依赖于两个库项目，库项目一链接： 
http://git.oschina.
      
                                
      • 
                                
    • Javascript中函数的toString()方法
                                    周凡杨
JavaScriptjstoStringfunctionobject
                                    
      简述 
    The toString() method returns a string representing the source code of the function. 
    简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。 
句法 
    function.
      
                                
      • 
                                
    • struts处理自定义异常
                                    g21121
struts
                                    
      很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。 
非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。 
此处我们用的是非运行时异常，首先定义一个异常LoginException: 
/**
 * 类描述：登录相
      
                                
      • 
                                
    • Linux中find常见用法示例
                                    510888780
linux
                                    
      Linux中find常见用法示例 
 
·find   path   -option   [   -print ]   [ -exec   -ok   command ]   {} \; 
 
 
 
 
find命令的参数；
      
                                
      • 
                                
    • SpringMVC的各种参数绑定方式
                                    Harry642
springMVC绑定表单
                                    
      1. 基本数据类型(以int为例，其他类似)： 
Controller代码： 
 

    @RequestMapping("saysth.do")
    public void test(int count) {
    }
 
表单代码： 
 

<form action="saysth.do" method="post&q
      
                                
      • 
                                
    • Java 获取Oracle ROWID
                                    aijuans
javaoracle
                                    
        
A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. 
The oracle.sql.ROWID class i
      
                                
      • 
                                
    • java获取方法的参数名
                                    antlove
javajdkparametermethodreflect
                                    
      reflect.ClassInformationUtil.java 
package reflect;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.Modifier;
import javassist.bytecode.CodeAtt
      
                                
      • 
                                
    • JAVA正则表达式匹配 查找 替换 提取操作
                                    百合不是茶
java正则表达式替换提取查找
                                    
      正则表达式的查找;主要是用到String类中的split(); 
      String str; 
     str.split();方法中传入按照什么规则截取,返回一个String数组 
  
常见的截取规则: 
str.split("\\.")按照.来截取

str.
      
                                
      • 
                                
    • Java中equals()与hashCode()方法详解
                                    bijian1013
javasetequals()hashCode()
                                    
      一.equals()方法详解 
    equals()方法在object类中定义如下：  
public boolean equals(Object obj) {
    return (this == obj);
}
 
   很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
      
                                
      • 
                                
    • 精通Oracle10编程SQL(4)使用SQL语句
                                    bijian1013
oracle数据库plsql
                                    
      --工资级别表
create table SALGRADE
(
  GRADE    NUMBER(10),
  LOSAL    NUMBER(10,2),
  HISAL    NUMBER(10,2)
)

insert into SALGRADE values(1,0,100);
insert into SALGRADE values(2,100,200);
inser
      
                                
      • 
                                
    • 【Nginx二】Nginx作为静态文件HTTP服务器
                                    bit1129
HTTP服务器
                                    
       Nginx作为静态文件HTTP服务器 
 
  在本地系统中创建/data/www目录，存放html文件(包括index.html) 
 创建/data/images目录，存放imags图片 
 在主配置文件中添加http指令 
 
  
http {
    server {
        listen       80;
        server_name  
      
                                
      • 
                                
    • kafka获得最新partition offset
                                    blackproof
kafkapartitionoffset最新
                                    
      kafka获得partition下标，需要用到kafka的simpleconsumer 
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.
      
                                
      • 
                                
    • centos 7安装docker两种方式
                                    ronin47

                                    
            第一种是采用yum 方式 
             yum install -y docker 
          
      
                                
      • 
                                
    • java-60-在O(1)时间删除链表结点
                                    bylijinnan
java
                                    
      

public class DeleteNode_O1_Time {

	/**
	 * Q 60 在O(1)时间删除链表结点
	 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点
	 * 
	 * Assume the list is:
	 * head->...->nodeToDelete->mNode->nNode->..
      
                                
      • 
                                
    • nginx利用proxy_cache来缓存文件
                                    cfyme
cache
                                    
      user  zhangy users;
worker_processes 10;
error_log  /var/vlogs/nginx_error.log  crit;
pid        /var/vlogs/nginx.pid;
#Specifies the value for ma
      
                                
      • 
                                
    • [JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题
                                    comsci
嵌入式
                                    
       
    假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做： 
 
    string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))" 
 
    定义一个0整数c,然后用这个整数c去
      
                                
      • 
                                
    • 如何集成支付宝官方文档
                                    dai_lm
android
                                    
      官方文档下载地址 
 
https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 
 
集成的必要条件 
1. 需要有自己的Server接收支付宝的消息 
2. 需要先制作app，然后提交支付宝审核，通过后才能集成 
 
调试的时候估计会真的扣款，请注意 

      
                                
      • 
                                
    • 应该在什么时候使用Hadoop
                                    datamachine
hadoop
                                    
      原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 
 
存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 
 
--------------------------------------------万能的分割线-------------------------------- 
有人问我，“你在大数据和Hado
      
                                
      • 
                                
    • 在GridView中对于有外键的字段使用关联模型进行搜索和排序
                                    dcj3sjt126com
yii
                                    
      在GridView中使用关联模型进行搜索和排序 
首先我们有两个模型它们直接有关联:   
class Author extends CActiveRecord {
...
}
 
class Post extends CActiveRecord {
...
    function relations() {
        return array(
            '
      
                                
      • 
                                
    • 使用NSString 的格式化大全
                                    dcj3sjt126com
Objective-C
                                    
      格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
      
                                
      • 
                                
    • 使用activeX插件对象object滚动有重影
                                    蕃薯耀
activeX插件滚动有重影
                                    
          
使用activeX插件对象object滚动有重影       <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
      
                                
      • 
                                
    • SpringMVC4零配置
                                    hanqunfeng
springmvc4
                                    
      基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。 
  
  
项目说明如下： 
1.db.sql是项目中用到的表，数据库使用的是oracle11g 
2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 
3.默认项目为零配置启动，如果需要更改启动方式，请
      
                                
      • 
                                
    • 《开源框架那点事儿16》：缓存相关代码的演变
                                    j2eetop
开源框架
                                    
      问题引入 
上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。 
该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。 
当然去看相关实现代代码的时候，大致是下面的样子。    
[java] 
view plain 
copy 
print 
?   
 
 public vo
      
                                
      • 
                                
    • AngularJS浅析
                                    kvhur
JavaScript
                                    
      概念 
 
 AngularJS is a structural framework for dynamic web apps. 
 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm 
 Directive 
扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
      
                                
      • 
                                
    • 架构师之jdk的bug排查(一)---------------split的点号陷阱
                                    nannan408
split
                                    
      1.前言. 
   jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 
2.代码 
 

String[] paths = "object.object2.prop11".split("'");
System.ou
      
                                
      • 
                                
    • 如何对10亿数据量级的mongoDB作高效的全表扫描
                                    quentinXXZ
mongodb
                                    
        本文链接: 
http://quentinXXZ.iteye.com/blog/2149440  
一、正常情况下，不应该有这种需求 
首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。 
说一下，
      
                                
      • 
                                
    • C语言算法之水仙花数
                                    qiufeihu
c算法
                                    
      /**
* 水仙花数
*/
#include <stdio.h>
#define N 10
int main()
{
    int x,y,z;
    for(x=1;x<=N;x++)
    	for(y=0;y<=N;y++)
    		for(z=0;z<=N;z++)
    			if(x*100+y*10+z == x*x*x
      
                                
      • 
                                
    • JSP指令
                                    wyzuomumu
jsp
                                    
       
 jsp指令的一般语法格式： <%@ 指令名 属性 =”值 ” %> 
  常用的三种指令： page,include,taglib 
 page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> 
 include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include
      
                                
      •