qq_389325968
qq_389325968

Spring5.0源码深度解析之Spring基于注解启动流程分析

主要内容：

一、IOC容器的初始化流

  • 创建IOC容器

  • 注册配置类

  • BeanFactory后置处理器

  • Bean的后置处理器

  • 创建Bean对象

IOC容器的初始化流程

从：

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);

进入：

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
   this();
   register(annotatedClasses);
   refresh();
}

一：创建IOC容器

1.this（）：先执行父类的初始化方法，创建IOC容器

public GenericApplicationContext() {
   this.beanFactory = new DefaultListableBeanFactory();
}

2.执行初始化方法创建BeanDefinition读取器和classPath下扫描器

public AnnotationConfigApplicationContext() {
   this.reader = new AnnotatedBeanDefinitionReader(this);
   this.scanner = new ClassPathBeanDefinitionScanner(this);
}

3.this.reader = new AnnotatedBeanDefinitionReader(this)的创建过程：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
   this(registry, getOrCreateEnvironment(registry));
}

4.执行AnnotatedBeanDefinitionReader的构造器：重点在最后一行的注册注解配置处理器

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   Assert.notNull(environment, "Environment must not be null");
   this.registry = registry;
   this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
   AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); //注册注解配置处理器
}

5.1这个方法把下面对象注册到IOC容器里面

Spring5.0源码深度解析之Spring基于注解启动流程分析_第1张图片

5.2ConfigurationClassPostProcessor对象注册的代码

public static Set registerAnnotationConfigProcessors(
      BeanDefinitionRegistry registry, @Nullable Object source) {

   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);    //创建IOC容器
   ....
   Set beanDefs = new LinkedHashSet<>(4);
   if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { //注册5.2ConfigurationClassPostProcessor对象到IOC容器中
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

6、执行this.scanner = new ClassPathBeanDefinitionScanner(this);

先走父类

public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters) {
   this(useDefaultFilters, new StandardEnvironment());
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
   this(registry, true);
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
   this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
      Environment environment) {

   this(registry, useDefaultFilters, environment,
         (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
      Environment environment, @Nullable ResourceLoader resourceLoader) {

   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   this.registry = registry;

   if (useDefaultFilters) {
      registerDefaultFilters();
   }
   setEnvironment(environment);
   setResourceLoader(resourceLoader);
}
protected void registerDefaultFilters() {
   this.includeFilters.add(new AnnotationTypeFilter(Component.class));
   ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
   try {
      this.includeFilters.add(new AnnotationTypeFilter(
            ((Class) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
      logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
   }
   catch (ClassNotFoundException ex) {
      // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
   }
   try {
      this.includeFilters.add(new AnnotationTypeFilter(
            ((Class) ClassUtils.forName("javax.inject.Named", cl)), false));
      logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
   }
   catch (ClassNotFoundException ex) {
      // JSR-330 API not available - simply skip.
   }
}

registerDefaultFilters（）把加了@Component注解的的class对象添加到includeFilters列表

Spring5.0源码深度解析之Spring基于注解启动流程分析_第2张图片

问题1：加了@Component注解的类是怎么注册到SpringIOC容器里面的？

二：注册配置类

1.register(annotatedClasses);把用户指定的类加载到IOC容器里面

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
   this();
   register(annotatedClasses);
   refresh();
}
public void register(Class... annotatedClasses) {
   Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
   this.reader.register(annotatedClasses);
}

2.进入上面创建的reader的注册方法里面

public void register(Class... annotatedClasses) {
   for (Class annotatedClass : annotatedClasses) {
      registerBean(annotatedClass);
   }
}
public void registerBean(Class annotatedClass) {
   doRegisterBean(annotatedClass, null, null, null);
}
 void doRegisterBean(Class annotatedClass, @Nullable Supplier instanceSupplier, @Nullable String name,
      @Nullable Class[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);//创建BeanDefinition对象
   if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {    //处理 @Condition注解
      return;
   }

   abd.setInstanceSupplier(instanceSupplier); //设置对象是单例模式还是多例模式，默认单例
   ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
   abd.setScope(scopeMetadata.getScopeName());    //获取BeanName,设置的化就采用默认值，否则类名第一个字母小写
   String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

   AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); //处理Lazy，primary等注解
   .....

   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);//判断对象是否需要代理，不需要直接返回，需要的化，重新创建BeanDefinition加入代理的信息
   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);    //注册配置类到IOC容器
}

3、调用shouldSkip（）处理@Condition注解

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
   if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) { //如果没有不是@Condition注解直接返回fasle
      return false;
   }
   if (phase == null) { //下面递归调用本方法
      if (metadata instanceof AnnotationMetadata &&
            ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
         return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
      }
      return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
   }
   List conditions = new ArrayList<>();
   for (String[] conditionClasses : getConditionClasses(metadata)) { //phase不为空的时候，执行所有condition类的match方法。
      for (String conditionClass : conditionClasses) {
         Condition condition = getCondition(conditionClass, this.context.getClassLoader());
         conditions.add(condition);
      }
   }
    ....
   return false;
}

4、调用processCommonDefinitionAnnotations处理下面的的注解

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
   AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
   if (lazy != null) {
      abd.setLazyInit(lazy.getBoolean("value"));
   }
   else if (abd.getMetadata() != metadata) {
      lazy = attributesFor(abd.getMetadata(), Lazy.class);
      if (lazy != null) {
         abd.setLazyInit(lazy.getBoolean("value"));
      }
   }
   if (metadata.isAnnotated(Primary.class.getName())) {
      abd.setPrimary(true);
   }
   AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
   if (dependsOn != null) {
      abd.setDependsOn(dependsOn.getStringArray("value"));
   }

   if (abd instanceof AbstractBeanDefinition) {
      AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
      AnnotationAttributes role = attributesFor(metadata, Role.class);
      if (role != null) {
         absBd.setRole(role.getNumber("value").intValue());
      }
      AnnotationAttributes description = attributesFor(metadata, Description.class);
      if (description != null) {
         absBd.setDescription(description.getString("value"));
      }
   }
}

三、BeanFactory后置处理器 1、beanFactory后置处理器（以ConfigurationClassPostProcessor为例）

1.1、ConfigurationClassPostProcessor继承关系

Spring5.0源码深度解析之Spring基于注解启动流程分析_第3张图片

1.2、接口说明

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
   void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}
public interface BeanFactoryPostProcessor {
   void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

2、refresh()->invokeBeanFactoryPostProcessors方法执行beanFactory后置处理器

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
   if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
}
public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

   //2.1.1、执行IOC容器beanFactoryPostProcessors列表里面存在的BeanDefinitionRegistryPostProcessor处理器
   //2.1.2、把实现了BeanDefinitionRegistryPostProcessor接口的对象放到registryPostProcessors列表
   //2.1.3、把只实现BeanFactoryPostProcessor接口的放到regularPostProcessors
   Set processedBeans = new HashSet<>();

   if (beanFactory instanceof BeanDefinitionRegistry) {
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      List regularPostProcessors = new LinkedList<>();
      List registryPostProcessors =
            new LinkedList<>();

      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryPostProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
            registryPostProcessors.add(registryPostProcessor);
         }
         else {
            regularPostProcessors.add(postProcessor);
         }
      }
      //2.2、获取所有注册到IOC容器里面的BeanDefinitionRegistryPostProcessor对象的beanName
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      //2.3、按照一定的顺序执行postProcessBeanDefinitionRegistry方法，并且放到registryPostProcessors列表
      List priorityOrderedPostProcessors = new ArrayList<>();
    ....

   else {
      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }
    //2.4、获取所有BeanFactoryPostProcessor对象并且执行postProcessBeanFactory方法
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
  ....
}

3、ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry方法

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    ....
   processConfigBeanDefinitions(registry);
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
      //注册BeanDefinitions
      this.reader.loadBeanDefinitions(configClasses);
      alreadyParsed.addAll(configClasses);
}

Spring5.0源码深度解析之Spring基于注解启动流程分析_第4张图片

Spring5.0源码深度解析之Spring基于注解启动流程分析_第5张图片

四、注册Bean的后置处理器：registerBeanPostProcessors(beanFactory);

1、注册bean后置处理器到IOC并且创建对象

public static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

....
    //根据实现的额接口不同，放入到不同的列表里面
   List priorityOrderedPostProcessors = new ArrayList<>();
   List internalPostProcessors = new ArrayList<>();
   List orderedPostProcessorNames = new ArrayList<>();
   List nonOrderedPostProcessorNames = new ArrayList<>();
   for (String ppName : postProcessorNames) {
      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
           //创建Bean
         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
....

....
}

五、创建Bean对象

1、refresh()->finishBeanFactoryInitialization()->preInstantiateSingletons()

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
 ....
   // Instantiate all remaining (non-lazy-init) singletons.
   beanFactory.preInstantiateSingletons();
}
@Override
public void preInstantiateSingletons() throws BeansException {
   if (this.logger.isDebugEnabled()) {
      this.logger.debug("Pre-instantiating singletons in " + this);
   }
   List beanNames = new ArrayList<>(this.beanDefinitionNames);
   for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);//是否创建对象
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         if (isFactoryBean(beanName)) {//是否是FactoryBean，是则调用getObject()方法
            final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
               isEagerInit = AccessController.doPrivileged((PrivilegedAction) () ->
                     ((SmartFactoryBean) factory).isEagerInit(),
                     getAccessControlContext());
            }
            else {
               isEagerInit = (factory instanceof SmartFactoryBean &&
                     ((SmartFactoryBean) factory).isEagerInit());
            }
            if (isEagerInit) {
               getBean(beanName);
            }
         }
         else {
            getBean(beanName);
         }
      }
   }

2、getBean(beanName)方法核心步骤

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

下面几个关键的方法需要分析下getSingleton，createBean 和 getObjectForBeanInstance

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

   final String beanName = transformedBeanName(name);
   Object bean;

   // Eagerly check singleton cache for manually registered singletons.
   Object sharedInstance = getSingleton(beanName);
   if (sharedInstance != null && args == null) {
     ....
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);//从Bean的实例中获取对象
   }

   else {
    ....
         // Create bean instance.
         if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
               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);
         }

         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, () -> {
                  beforePrototypeCreation(beanName);
                  try {
                     return createBean(beanName, mbd, args);
                  }
                  finally {
                     afterPrototypeCreation(beanName);
                  }
               });
               bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
            }
           ....
   }
....
   return (T) bean;
}

getSingleton方法执行流程【缓存中获取单例bean】

bean的加载过程。单例bean在spring容器中只会被创建一次，后续再获取Bean直接从单例缓存中获取，当然这里也只是尝试加载，首先尝试从缓存中加载，然后再次尝试从singletonFactories中加载。

因为在创建单例bean 的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，spring创建bean的原则是不等bean创建完成就会将创建的bean的ObjectFactory提早曝光加入到缓存中，

一旦下一个bean创建时需要 依赖上一个Bean，则直接使用ObjectFactory。

public Object getSingleton(String beanName) {
   return getSingleton(beanName, true);//参数true设置标识允许早期依赖
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);//检查缓存中是否存在实例
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {//如果为空
      synchronized (this.singletonObjects) {//如果为空，则锁定全局变量进行处理
         singletonObject = this.earlySingletonObjects.get(beanName);//如果此bean正在加载，则不会处理后面逻辑
         if (singletonObject == null && allowEarlyReference) {//当某些方法需要提前初始化的时候
            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();//调用预先设定的getObject方法，创建bean
               this.earlySingletonObjects.put(beanName, singletonObject);//记录在缓存中earlySingletonObjects和singletonFactories互斥
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}
private final Map singletonObjects = new ConcurrentHashMap<>(256);
private final Map> singletonFactories = new HashMap<>(16);
private final Map earlySingletonObjects = new HashMap<>(16);
private final Set registeredSingletons = new LinkedHashSet<>(256);

Spring5.0源码深度解析之Spring基于注解启动流程分析_第6张图片

  • singletonObjects:用于保存BeanName和创建Bean实例之间的关系，bean name->bean instance
  • singletonFactories:用于保存BeanName和创建bean工厂之间的关系，bean name->ObjectFactory
  • earlySingletonObjects:也是保存BeanName和创建Bean实例之间的关系，与singletonObjects不同在于，当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getBean方法获取到了，其目的是为了检测循环引用。
  • registeredSingletons：用来保存当前所有已注册的Bean

getObjectForBeanInstance方法执行流程

在getBean方法中，getObjectForBeanInstance是个高频率使用的方法，无论是从缓存中获取bean还是根据不同的scope策略加载bean。总之我们得到Bean的实例后要做的第一步就是调用这个方法来检测当前Bean是否是FactoryBean类型

如果是，那么需要调用该Bean对应 的FactoryBean实例中的getObject()作为返回值。

无论是从缓存中获取到Bean还是通过不同的scope策略加载的Bean都只是最原始的Bean状态，并不一定是我们想要的Bean。

举个例子：假如我们需要对工厂Bean进行处理，那么这里得到的是工厂Bean的初始状态，但是我们正真需要的是工厂Bean中定义的factory-method方法中返回的Bean，而getObjectForBeanInstance方法就是完成这个工作的。

下面来分析下getObjectForBeanInstance这个方法：

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

   // 如果指定的name是工厂相关（以&为前缀）且BeanInstance又不是FactoryBean类型则验证不通过
   if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
      throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
   }

   // 现在我们有了这个Bean实例，这个实例可能会是正常的Bean或者FactoryBean
   // 如果是FactoryBean我们使用它创建实例，但是如果用户想要直接获取工厂实例而不是工厂的getObject方法对应的实例，那么传入的name应该加入前缀&
   if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
      return beanInstance;
   }
   //加载FactoryBean
   Object object = null;
   if (mbd == null) {
      //尝试从缓存中加载Bean
      object = getCachedObjectForFactoryBean(beanName);
   }
   if (object == null) {
      // 到这块已经明确了beanInstance一定是FactoryBean类型
      FactoryBean factory = (FactoryBean) beanInstance;
      // Caches object obtained from FactoryBean if it is a singleton.
      if (mbd == null && containsBeanDefinition(beanName)) {
         mbd = getMergedLocalBeanDefinition(beanName);
      }
      //是否是用户定义的而不是应用程序本身定义的
      boolean synthetic = (mbd != null && mbd.isSynthetic());
      object = getObjectFromFactoryBean(factory, beanName, !synthetic);
   }
   return object;
}

从上面代码来看，大多是些辅助代码以及一些功能性的判断，而正真的核心委托给getObjectFromFactoryBean，我们来看看这个方法：

这个方法里面只做了一件事情，就是返回的Bean如果是单例，那么就必须要保证全局唯一，同时也因为是单例的，所以不必重复创建，可以使用缓存来提高性能，

也就是说，以及加载过就要记录下来以便于下次复用，否则的化就直接获取了。

protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {
   if (factory.isSingleton() && containsSingleton(beanName)) {//如果是单例模式
      synchronized (getSingletonMutex()) {//锁住全局变量
         Object object = this.factoryBeanObjectCache.get(beanName);
         if (object == null) {
            object = doGetObjectFromFactoryBean(factory, beanName);
           //缓存中获取bean
            Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
            if (alreadyThere != null) {
               object = alreadyThere;
            }
            else {
               if (shouldPostProcess) {
                  try {
                     object = postProcessObjectFromFactoryBean(object, beanName);
                  }
                  catch (Throwable ex) {
                     throw new BeanCreationException(beanName,
                           "Post-processing of FactoryBean's singleton object failed", ex);
                  }
               }
               this.factoryBeanObjectCache.put(beanName, object);
            }
         }
         return object;
      }
   }
   else {
      Object object = doGetObjectFromFactoryBean(factory, beanName);//执行这个方法，会去调用getObject方法
      if (shouldPostProcess) {
         try {
            object = postProcessObjectFromFactoryBean(object, beanName);//调用ObjectFactory的后处理器
         }
         catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
         }
      }
      return object;
   }
}

下面看下：doGetObjectFromFactoryBean方法：

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

   Object object;
   try {
      if (System.getSecurityManager() != null) {//需要权限验证
         AccessControlContext acc = getAccessControlContext();
         try {
            object = AccessController.doPrivileged((PrivilegedExceptionAction) () ->
                  factory.getObject(), acc);
         }
         catch (PrivilegedActionException pae) {
            throw pae.getException();
         }
      }
      else {
         object = factory.getObject();//直接调用getObject方法
      }
   }
...
   return object;
} 
  
 
   
上面我们已经讲述了FactoryBean的调用方法，如果Bean声明为FactoryBean类型，则当提取Bean的时候取到的并不是FactoryBean而是FactoryBean中对应的getObject方法返回的Bean，
 
   
而doGetObjectFromFactoryBean正是实现了这个功能的。但是我们看到了上面的方法中除了调用object = factory.getObject()得到我们想要的结果后并没有直接返回，而是接下来又调用
 
   
postProcessObjectFromFactoryBean来做后置处理，我们进入这个后置处理方法，看看：
 
  
 
  
Spring5.0源码深度解析之Spring基于注解启动流程分析_第7张图片
 
  
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
   return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
 
  
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}
 
  
 
   
对于后置处理器的使用，后续会讲解到，这里我们需要明确一点：在Spring中获取Bean的规则中有一条：尽可能保证所有的Bean初始化后都会调用注册的
 
   
BeanPostProcessor的postProcessAfterInitialization方法进行处理，在实际开发中大可以争对此特性设计自己的业务逻辑。
 
  
 
  
获取单例：
 
  
// Create bean instance.
if (mbd.isSingleton()) {
   sharedInstance = getSingleton(beanName, () -> {
      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);
}
 
  
如果缓存不存在已经加载的单例Bean，就需要从头开始Bean的加载过程，而Spring中使用了getSingleton的重载方法实现Bean的加载过程
 进入getSingleton方法
 
  
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
   Assert.notNull(beanName, "Bean name must not be null");
   synchronized (this.singletonObjects) {
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
         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 + "'");
         }
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
            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;
            }
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}
 
  
protected void beforeSingletonCreation(String beanName) {
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {//将当前需要创建的Bean记录在缓存中，这样可以对循环依赖进行检测
      throw new BeanCurrentlyInCreationException(beanName);
   }
}
 
  
protected void afterSingletonCreation(String beanName) {
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {//当Bean加载结束后需要移除缓存中对该Bean的正在加载状态的记录
      throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
   }
}
 
  
返回处理结果
 
  
 
   
虽然我们已经从外部了解到了加载Bean的逻辑架构，但现在我们还并没有开始对Bean加载功能的探索，之前提到过，Bean的加载逻辑其实是在传入的ObjectFactory类型的参数singletonFactory中定义的，
 
   
我们反推参数的获取，得到如下的代码：
 
  
 
  
sharedInstance = getSingleton(beanName,new ObjectFactory() {
      public Object getObject() throws BeansException{
        try{
             return createBean(beanName, mbd, args);
        }catch(BeansException ex){
            destroySingleton(beanName);
            throw ex;
        }
      }
}) 
  
 
   
ObjectFactory的核心部分其实只是调用了createBean的方法，所以我们还需要到createBean方法中寻找真理！
 
  
 
  
准备创建Bean [createBean方法执行流程]
 
  
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
....
   try {
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isDebugEnabled()) {
         logger.debug("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
....
}
 
  
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {

....
   try {
      populateBean(beanName, mbd, instanceWrapper);
      exposedObject = initializeBean(beanName, exposedObject, mbd);
   }
  .....
}
 
  
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      invokeAwareMethods(beanName, bean);//执行aware接口相关方法
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);//Bean后置处理器的前置方法
   }

   try {
      invokeInitMethods(beanName, wrappedBean, mbd);//执行初始化的方法
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);//Bean后置处理器的后置方法
   }

   return wrappedBean;
} 
  
 
   
此方法中最吸引我们的无疑是两个方法：applyBeanPostProcessorsBeforeInitialization以及applyBeanPostProcessorsAfterInitialization。这两个方法是实现非常简单，
 
   
无非是对后处理器中的所有 InstantiationAwareBeanPostProcessor类型的后置处理器BeanPostProcessor进行postProcessBeforeInitialization方法和postProcessAfterInitialization方法的调用
 
  
 
  
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}
 
  
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}
 
  
 
   
根据上面代码可知：Bean的实例化前调用，也就是将AbstractBeanDefinition转换为BeanWrapper前的处理。给子类一个修改BeanDefinition的机会，也就是说当程序经过这个方法后，
 
   
Bean可能已经不是我们认为的Bean了，而是经过代理后的Bean，可能是CGLIB生成的，也可能是通过其它技术生成的。后面会分析到。
 
  
 
  
到这里，结束创建单例的对象
 
  
Spring5.0源码深度解析之Spring基于注解启动流程分析_第8张图片
 
  
Spring5.0源码深度解析之Spring基于注解启动流程分析_第9张图片
 
  
SpringBean的生命周期总结
 
  
源码分析流程：
 
  
 
   
1、执行refresh（）刷新方法
 
   
2、finishBeanFactoryInitialization(beanFactory);
 
   
3、beanFactory.preInstantiateSingletons();
 
   
4、getBean(beanName)->doGetBean()->createBean()->doCreateBean()->createBeanInstance()初始化对象（默认情况下使用Java反射机制初始化对象，也可以通过CGLIB）
 
   
5、initializeBean（）
 
   
6、invokeAwareMethods（）判断是否有Aware接口依赖信息
 
   
7、applyBeanPostProcessorsBeforeInitialization（）执行前置处理
 
   
8、invokeInitMethods（）执行init()方法
 
   
8、applyBeanPostProcessorsAfterInitialization（）执行后置处理
 
  
 
  
本文参考：
 
  
书籍：Spring源码深度解析
 
  
蚂蚁课堂：http://www.mayikt.com/
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring,源码分析,spring,源码分析)

        

            

                
    
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

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

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • Golang Channel
                        PandaSkr
golang
                        
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                    
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
                        "小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
                        
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    
                    
    • 
                    
  • java 技术 架构 相关文档
                        圣心
java架构开发语言
                        
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    
                    
    • 
                    
  • SpringSecurity初学总结
                        weixin_66442229
spring
                        
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
    
                    
    • 
                                
  • PHP，安卓，UI，java，linux视频教程合集
                                    cocos2d-x小菜
javaUIlinuxPHPandroid
                                    
    ╔-----------------------------------╗┆                           
    
                                
    • 
                                
  • zookeeper admin 笔记
                                    braveCS
zookeeper
                                    
      
Required Software 
1) JDK>=1.6 
2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 
3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘 
   


数据和日志目录  
1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
    
                                
    • 
                                
  • Spring配置多个连接池
                                    easterfly
spring
                                    
    项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ 
Spring中有关于dataSource的配置： 
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 
  &nb
    
                                
    • 
                                
  • Mysql
                                    171815164
mysql
                                    
    例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 
 
GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI 
 
TH GRANT OPTION; 
 
如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
    
                                
    • 
                                
  • CommonDAO（公共/基础DAO）
                                    g21121
DAO
                                    
            好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。 
        DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
    
                                
    • 
                                
  • 直言有讳
                                    永夜-极光
感悟随笔
                                    
      
1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313 
  
精华: 
“直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
    
                                
    • 
                                
  • 安装CentOS 7 和Win 7后，Win7 引导丢失
                                    随便小屋
centos
                                    
    一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。 
一、首先具有root 的权限。 
     即进入Terminal后输入命令su，然后输入密码即可 
二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 
v
    
                                
    • 
                                
  • Oracle备份与恢复案例
                                    aijuans
oracle
                                    
    Oracle备份与恢复案例 
一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
    
                                
    • 
                                
  • JavaEE开源快速开发平台G4Studio v5.0发布
                                    無為子

                                    
      
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。 
  
访问G4Studio网站  
http://www.g4it.org       
2013-04-06 发布G4Studio_V5.0版本 
功能新增 
(1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
    
                                
    • 
                                
  • Oracle显示根据高考分数模拟录取
                                    百合不是茶
PL/SQL编程oracle例子模拟高考录取学习交流
                                    
    题目要求: 
1,创建student表和result表
2,pl/sql对学生的成绩数据进行处理
3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选 
  
  
1,创建student表,和result表 
学生信息表; 
create table student(
   student_id number primary key,--学生id
    
                                
    • 
                                
  • 优秀的领导与差劲的领导
                                    bijian1013
领导管理团队
                                    
    责任 

  优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。 
  
 差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。 
 
努力工作 

  优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
    
                                
    • 
                                
  • js函数在浏览器下的兼容
                                    Bill_chen
jquery浏览器IEDWRext
                                    
      做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同： 
 
  IE6：node.nextSibling,对于FF是不能识别的； 
 
  FF：node.nextElementSibling,对于IE是不能识别的； 
 
兼容解决方式：var Div = node.nextSibl
    
                                
    • 
                                
  • 【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC)
                                    bit1129
垃圾回收
                                    
    吞吐量与用户线程暂停时间 
  
衡量垃圾回收算法优劣的指标有两个： 
 
 吞吐量越高，则算法越好 
 暂停时间越短，则算法越好 
 
首先说明吞吐量和暂停时间的含义。 
  
垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
    
                                
    • 
                                
  • J2EE监听器和过滤器基础
                                    白糖_
J2EE
                                    
     Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。 
监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。 
  
 
 ServletContex监听器 
   ServletContex又叫application
    
                                
    • 
                                
  • 博弈AngularJS讲义(16) - 提供者
                                    boyitech
jsAngularJSapiAngularProvider
                                    
      Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。 
  那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
    
                                
    • 
                                
  • java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。
                                    bylijinnan
java
                                    
    

public class CommonSubSequence {

	/**
	 * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。
	 * 写一个版本算法复杂度O(N^2)和一个O(N) 。
	 * 
	 * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。
	 * O(
    
                                
    • 
                                
  • sqlserver 2000 无法验证产品密钥
                                    Chen.H
sqlwindowsSQL ServerMicrosoft
                                    
    在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。 这样做, 收到以下错误信息CD KEY的 SQ
    
                                
    • 
                                
  • [新概念武器]气象战争
                                    comsci

                                    
     
 
       气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织.... 
 
       原因如下: 
 
       地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
    
                                
    • 
                                
  • oracle 中 rollup、cube、grouping 使用详解
                                    daizj
oraclegroupingrollupcube
                                    
    oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示 转自namesliu 
 
-- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景  
  
--- ROLLUP ， 为了理解分组的成员数量，我增加了 分组的计数  COUNT(SAL)  
 
    
                                
    • 
                                
  • 技术资料汇总分享
                                    Dead_knight
技术资料汇总 分享
                                    
    本人汇总的技术资料，分享出来，希望对大家有用。 
 
http://pan.baidu.com/s/1jGr56uE 
 
资料主要包含： 
Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) 
Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) 
Ser
    
                                
    • 
                                
  • 初一下学期难记忆单词背诵第一课
                                    dcj3sjt126com
englishword
                                    
    could 能够 
minute 分钟 
Tuesday 星期二 
February 二月 
eighteenth 第十八 
listen 听 
careful 小心的，仔细的 
short 短的 
heavy 重的 
empty 空的 
certainly 当然 
carry 携带；搬运 
tape 磁带 
basket 蓝子 
bottle 瓶 
juice 汁，果汁 
head 头；头部 

    
                                
    • 
                                
  • 截取视图的图片, 然后分享出去
                                    dcj3sjt126com
OSObjective-C
                                    
    OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. 
I implemented a category method on UIView to get the vi
    
                                
    • 
                                
  • MySql重置密码
                                    fanxiaolong
MySql重置密码
                                    
    方法一: 
 在my.ini的[mysqld]字段加入： 
skip-grant-tables 
重启mysql服务，这时的mysql不需要密码即可登录数据库 
 然后进入mysql 
mysql>use mysql; 
 mysql>更新 user set password=password('新密码') WHERE User='root'; 
mysq
    
                                
    • 
                                
  • Ehcache（03）——Ehcache中储存缓存的方式
                                    234390216
ehcacheMemoryStoreDiskStore存储驱除策略
                                    
    Ehcache中储存缓存的方式 
  
目录 
1     堆内存（MemoryStore） 
1.1     指定可用内存 
1.2     驱除策略 
1.3     元素过期 
2   &nbs
    
                                
    • 
                                
  • spring mvc中的@propertysource
                                    jackyrong
spring mvc
                                    
      在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： 
 
@PropertySource  在spring 3.1中开始引入 
 
比如有配置文件 
config.properties 
 
mongodb.url=1.2.3.4 
mongodb.db=hello 
 
则代码中 
  

@PropertySource(&
    
                                
    • 
                                
  • 重学单例模式
                                    lanqiu17
单例Singleton模式
                                    
    最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。 
	第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。
	单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式
	静态内部类方式: 
package test.pattern.singleton.statics;

publ
    
                                
    • 
                                
  • .NET开源核心运行时，且行且珍惜
                                    netcome
java.net开源
                                    
    背景 
2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
    
                                
    • 
                                
  • 使用oscahe缓存技术减少与数据库的频繁交互
                                    Everyday都不同
Web高并发oscahe缓存
                                    
    此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。 
  
缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
    
                                
    • 
                                
  • Spring+Mybatis 手动控制事务
                                    toknowme
mybatis
                                    
    @Override 
   public boolean testDelete(String jobCode) throws Exception { 
      boolean flag = false; 
 &nbs
    
                                
    • 
                                
  • 菜鸟级的android程序员面试时候需要掌握的知识点
                                    xp9802
android
                                    
    熟悉Android开发架构和API调用 
掌握APP适应不同型号手机屏幕开发技巧 
熟悉Android下的数据存储  
熟练Android Debug Bridge Tool 
熟练Eclipse/ADT及相关工具  
熟悉Android框架原理及Activity生命周期 
熟练进行Android UI布局 
熟练使用SQLite数据库； 
熟悉Android下网络通信机制，S
    
                                
    •