kiwi5691
kiwi5691

SPRING源码5.0：容器的功能扩展BeanFactoryPostProcessor

BeanFactory的后处理

BeanFactory作为Spring中容器功能的基础，用于存放所有已经加载的bean，为了保证程序上的高可扩展性，SPring针对BeanFactory做了大量的扩展，如PostProcessor等就是在在此实现的。

激活注册的BeanFactoryPostProcessor

BeanFactoryPostProcessor接口同BeanPostProcessor类型，可对bean的定义（配置元数据）进行处理，也就是说。

  • SpringIoc 容器允许BeanFactoryPostProcessor在容器实际实例化任何其他的bean之前读取配置元数据，并有可能修改它。
  • 你可以配置多个BeanFactoryPostProcessor，也可以通过设置“order"属性来控制BeanFactoryPostProcessor的执行次序，仅当实现了Ordered接口才可以设置。
  • 如果想改变实际的bean实例（列如从配置元数据创建的对象），那么最好使用BeanPostProcessor
  • BeanFactoryPostProcessor的作用域范围是容器级的。它只和你使使用的容器有关。
  • 它只会对你定义的此容器进行后置处理，另一个不会，即使这两个容器在统一层次上

BeanFactoryPostProcessor的典型应用，如PropertyPlacholderConfigurer

使用了国际化



${bean.message}

${bean.message}的配置在bean.property中设置值
Spring框架靠PropertyPlaceHolderConfigurer类来找到这个properties配置



config/bean.properties

ProperrtyPlaceHolderConfigurer这个类间接继承了BeanFactoryPostProcessor接口。
当Spring加载任何实现了这个接口的bean的配置时，都会在bean工厂载入所有bean的配置后执行postProcessBeanFactory方法。在PropertyResourceConfigurer类中实现了postProcessBeanFactory方法。此方法先后调用了mergeProperties，convertProperties，processProperly这三个方法分别得到配置，将得到的配置转换为合适类型，最后将配置内容告知BeanFactory。
BeanFactoryPostProcessor接口，BeanFactory会在实例化任何bean之前获得配置信息，从一能够正确解析bean描述文件中的变量引用。

使用自定义BeanFactoryPostProcessor

具体使用网上可查询

通过implements BeanFactoryPostProcessor实现postProcessBeanFactory
引用的时候

configurableListableBeanFactory bf = new XmlBeanFactory(new ClassPathResource("/META-INF/BeanFactory.xml"));
BeanFactoryPostProcessor bfpp=(BeanFactoryPostProcessor)bf.getBean("bfpp");
bfpp.postProcessBeanFactory(bf);//通过实现此方法
//使用

激活BeanFactoryPostProcessor

我们看一下BeanFactoryPostProcessor的调用过程

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//主逻辑在invokeBeanFactoryProcessors  
 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

   // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
   // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
   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) {

   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
   Set processedBeans = new HashSet<>();
//对BeanDefinitionRegistery类型的处理
   if (beanFactory instanceof BeanDefinitionRegistry) {
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      List regularPostProcessors = new ArrayList<>();
      List registryProcessors = new ArrayList<>();

//硬编码注册的后处理
      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            //对于BeanDefinitionRegistryPostProcessor类型，在BeanFactoryPostProcessor的基础上还要自己定义的方法，需要先调用
     registryProcessor.postProcessBeanDefinitionRegistry(registry);
            registryProcessors.add(registryProcessor);
         }
         else {
//记录常规BeanFactoryPostProcessor
            regularPostProcessors.add(postProcessor);
         }
      }

//配置注册的后处理
      // Do not initialize FactoryBeans here: We need to leave all regular beans
      // uninitialized to let the bean factory post-processors apply to them!
      // Separate between BeanDefinitionRegistryPostProcessors that implement
      // PriorityOrdered, Ordered, and the rest.
      List currentRegistryProcessors = new ArrayList<>();

      // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            processedBeans.add(ppName);
         }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
   //激活postProcessorBeanFactory方法，之前激活的时postProcessBeanDefinitionRegistry
//硬编码设置的BeanDefinitionRegistryPostProcessor 
     invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
      postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
         if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            processedBeans.add(ppName);
         }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
      boolean reiterate = true;
      while (reiterate) {
         reiterate = false;
         postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
         for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName)) {
               currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
               processedBeans.add(ppName);
               reiterate = true;
            }
         }
         sortPostProcessors(currentRegistryProcessors, beanFactory);
         registryProcessors.addAll(currentRegistryProcessors);
         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
         currentRegistryProcessors.clear();
      }

      // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
      invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
      invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   }

   else {
      // Invoke factory processors registered with the context instance.
      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }

   // Do not initialize FactoryBeans here: We need to leave all regular beans
   // uninitialized to let the bean factory post-processors apply to them!
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   List priorityOrderedPostProcessors = new ArrayList<>();
   List orderedPostProcessorNames = new ArrayList<>();
   List nonOrderedPostProcessorNames = new ArrayList<>();
//对后处理进行分类    
for (String ppName : postProcessorNames) {
      if (processedBeans.contains(ppName)) {
         // skip - already processed in first phase above
      }
      else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
         priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
      }
//设置优先级
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
   List orderedPostProcessors = new ArrayList<>();
   for (String postProcessorName : orderedPostProcessorNames) {
      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

//无序，直接调用
   // Finally, invoke all other BeanFactoryPostProcessors.
   List nonOrderedPostProcessors = new ArrayList<>();
   for (String postProcessorName : nonOrderedPostProcessorNames) {
      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

   // Clear cached merged bean definitions since the post-processors might have
   // modified the original metadata, e.g. replacing placeholders in values...
   beanFactory.clearMetadataCache();
}

对BeanFactoryPostProcessor的处理主要分两种情况进行

  • 对于BeanDefinitionRegistry类的特殊处理
  • 对普通BeanFactoryPostProcessor机械能处理

每种都需要考虑到硬编码注入的后处理器以及通过配置注入的后处理器。

BeanDefinitionRegistry类型的处理类的处理包括

  • 对于硬编码注册的后处理器结果，主要时通过AbstractApplicationContext中的添加处理器方法addBeanFactoryPostProcessor进行添加
public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor beanFactoryPostProcessor){
this.beanFactoryPostProcessors.add(beanFactoryPostProcessor);
}
  • 添加后的后处理器会存放在beanFactoryPostProcessors中，而在处理BeanFactoryPostProcessor时会首先检测beanFactoryPostProcessors是否有数据。
  • BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor，不但有BeanFactoryPostProcessor的特性，同时还有自定义的个性方法。也需要在此调用。
  • 所有这里需要从beanFactoryPostProcessors中跳出BeanDefinitionRegistryPostProcessor的后处理器，并进行其postProcessBeanDefintionRegistry方法的激活。

记录后处理器主要使用了3个List完成

  • registryPostProcessors：记录通过硬编码方法注册的BeanDefinitionRegistryPostProcessors类型的处理器
  • regularPostProcessors：记录通过硬编码方式注册的BeanFactoryPostProcessors类型的处理器
  • registryPostProcessorBeans：记录哦通过配置放注册的BeanDefinitionRegistryPostProcessors类型的处理器

对以上记录的List中的后处理器进行统一调用BeanFactoryPostProcessor的

PostProcessorsBeanFactory方法

对beanFactoryPostProcessors中非BeanDefinitionRegistryPostProcessor类型的后处理器进行

统一的BeanFactoryPostProcessor的postProcessFactory方法调用

普通beanFactory处理

BeanDefinitionRegistryPostProcessor只对BeanDefinitiionRegistry类型的ConfigurableListableBeanFactory有效。所以如果判断所示的beanFactory并不是BeanDefinitionRegistry，那么便可以忽略BeanDefinitionRegistryPostProcessor，而直接处理BeanFactoryPostProcessor，当然获取的方式与上面的获取类型
对于硬编码方式手动台南佳的后处理器时不需要做任何排序的，但是在配置文件中读取的处理器，Spring并不保证读取的顺序，所以需要按照PriorityOrdered或者Ordered的顺序调用

注册BeanPostProcessor

上文提到了BeanFactoryPostProcessors的调用，现在看下BeanPostProcessor。但是这里不是调用，而是注册。
真正的调用是在bean的实例化阶段进行的，Spring中大部分功能都是通过后处理的方式进行扩展的。这是Spring框架的一个特性，但是在BeanFactory中其实并没有实现后处理的自动注册。所以在调用的时候如果没有进行手动注册其实是不能使用的。但是ApplicationContext中却添加了自动注册功能。
如，定义一个后处理器

public class MyInsatantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{
public Object postProcessBeforeInitialization(Object bean,String beanNamee) throws BeansException{
System.out.println("==");
return null;
}
...
}

在配置文件中添加

那么使用BeanFactory方式进行Spring的bean的加载时是不会有任何变化的，但是如果使用ApplicationContext方法获取bean的时候就会在获取每个bean时打印 ===，而这个体现就是在registerBeanPostProcessors方法中完成。

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

   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

   // Register BeanPostProcessorChecker that logs an info message when
   // a bean is created during BeanPostProcessor instantiation, i.e. when
   // a bean is not eligible for getting processed by all BeanPostProcessors.

   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

   // Separate between BeanPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   List priorityOrderedPostProcessors = new ArrayList<>();
   List internalPostProcessors = new ArrayList<>();
//Orered保证顺序，上面是PriorityOrdered
   List orderedPostProcessorNames = new ArrayList<>();
   List nonOrderedPostProcessorNames = new ArrayList<>();
   for (String ppName : postProcessorNames) {
      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
         priorityOrderedPostProcessors.add(pp);
         if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
         }
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

//注册所有实现PriorityOrdered的BeanPostProcessor
   // First, register the BeanPostProcessors that implement PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

//注册所有实现Ordered的BeanPostProcessor
   // Next, register the BeanPostProcessors that implement Ordered.
   List orderedPostProcessors = new ArrayList<>();
   for (String ppName : orderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      orderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

//注册所有无序的BeanPostProcessor
   // Now, register all regular BeanPostProcessors.
   List nonOrderedPostProcessors = new ArrayList<>();
   for (String ppName : nonOrderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      nonOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

//
//注册所有实现MergedBeanDefinitionPostProcessor类型的BeanPostProcessor，并非重复注册
//在beanFactory.addBeanPostProcessor中会异常已经存在的BeanPostProcessor  
 // Finally, re-register all internal BeanPostProcessors.
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

//添加ApplicationListener探测器
   // Re-register post-processor for detecting inner beans as ApplicationListeners,
   // moving it to the end of the processor chain (for picking up proxies etc).
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

对于BeanPostProcessor的处理与BeanFactoryPostProcessor的处理极为相似。不同：

  • 对于BeanFactoryPostProcessor的处理分两种，一是通过硬编码方式的处理，另一种是通过配置文件的处理
  • BeanPostProcessor的处理只考虑了配置文件的方式而不考虑硬编码的反射
  • BeanFactoryPostProcessor的处理们不但要实现注册功能，而且还有对后处理器进的激活操作，所以在载入配置中的定义，并进行激活
  • BeanPostProcessor并不需要马上调用，硬编码实现的功能是将后处理器提取并调用。这里不需要调用，这里只需要将配置文件的BeanPostProcessor提取处理并注册进入beanFactory就可以了

Spring中支持对于BeanPostProcessor的排序，如根据PriorityOrdered进行排序，根据Ordered进行排序or无序。而Spring在BeanPostProcessor的激活顺序的时候也会考虑对于顺序的问题而进行排序。
internalPostProcessors中存储的后处理器也就是MergedBeanDefinitionPostProcessor类型的处理器重复调用了。是去确保beanPostProcessor的唯一性。在registerBeanProcessors中保存分类使用了add和remove

invokeBeanFactoryPostProcessors 中

for (String ppName : postProcessorNames) {
   if (processedBeans.contains(ppName)) {
      // skip - already processed in first phase above
   }
   else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
      priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
   }
   else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
      orderedPostProcessorNames.add(ppName);
   }
   else {
      nonOrderedPostProcessorNames.add(ppName);
   }
}

private static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List postProcessors) {

   for (BeanPostProcessor postProcessor : postProcessors) {
      beanFactory.addBeanPostProcessor(postProcessor);
   }
}

初始化消息资源

国际化

Spring定义了访问国际化信息的MessageSource接口，并提供了国际化信息的MessageSource接口。并提供了几个医用的实现类MessageSource分别对HierarchicalMessageSource和ApplicationContext接口扩展

  • HierarchicalMessageSource接口最重要的两个实现类是ResourceBundleMessageSource和ReloadableResourceBundleMessageSource，他们是基于Java的ResourceBundle基础类实现，允许仅通过资源名加载国际化资源。
  • ReloadableResourceBundleMessageSource提供了定时刷新功能，允许在不重启系统情况更新资源的信息。
  • StaticMessageSource主要用于程序测试，它预先通过编程的方式提供国际化信息。而DelegatingMessageSource是为方便父MessageSource而提供的代理类。

在initMessageSource中获取自定义资源文件的方式为beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME.MessageSource.class)，这里Spring使用了硬编码的方式硬性规定了定义资源文件必须为message，否则会获取不到自定义资源配置。

protected void initMessageSource() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
      this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
      // Make MessageSource aware of parent MessageSource.
      if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
         HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
         if (hms.getParentMessageSource() == null) {
            // Only set parent context as parent MessageSource if no parent MessageSource
            // registered already.
            hms.setParentMessageSource(getInternalParentMessageSource());
         }
      }
      if (logger.isDebugEnabled()) {
         logger.debug("Using MessageSource [" + this.messageSource + "]");
      }
   }
   else {
      // Use empty MessageSource to be able to accept getMessage calls.
      DelegatingMessageSource dms = new DelegatingMessageSource();
      dms.setParentMessageSource(getInternalParentMessageSource());
      this.messageSource = dms;
      beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
      if (logger.isDebugEnabled()) {
         logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
               "': using default [" + this.messageSource + "]");
      }
   }
}

初始化ApplicationEventMulticaster

Spring的事件传播器。
Spring的事件监听用法具体可以网上查询。一种基于设计模式的观察者模式

initApplicationEventMulticaster的方式比较简单。

  • 如果用户自定义了事件广播器，那么使用用户自定义的事件广播器
  • 如果用户没有自定义事件广播器，那么使用默认的ApplicationEventMulticaster

protected void initApplicationEventMulticaster() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
      this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
      if (logger.isDebugEnabled()) {
         logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
      }
   }
   else {
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
      if (logger.isDebugEnabled()) {
         logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
               APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
               "': using default [" + this.applicationEventMulticaster + "]");
      }
   }
}

按照逻辑，作为广播器，一定是用于存放监听器并在合适的时候调用监听器。
默认的广播器实现SimplApplicationEventMulticaster

@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
   ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
   for (final ApplicationListener listener : getApplicationListeners(event, type)) {
      Executor executor = getTaskExecutor();
      if (executor != null) {
         executor.execute(() -> invokeListener(listener, event));
      }
      else {
         invokeListener(listener, event);
      }
   }
}

当产生Spring事件时候会默认使用SimpleApplicationEventMulticaster的multicastEvent来广播事件，遍历所有的监听器，并使用监听器中的方法进行监听器的处理。而对于每个监听器来说其实都可以获取到对应的事件，但是是否进行处理则由事件监听器来决定。

注册监听器

protected void registerListeners() {
   // Register statically specified listeners first.
   for (ApplicationListener listener : getApplicationListeners()) {
      getApplicationEventMulticaster().addApplicationListener(listener);
   }

   // Do not initialize FactoryBeans here: We need to leave all regular beans
   // uninitialized to let post-processors apply to them!
   String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
   for (String listenerBeanName : listenerBeanNames) {
      getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
   }

   // Publish early application events now that we finally have a multicaster...
   Set earlyEventsToProcess = this.earlyApplicationEvents;
   this.earlyApplicationEvents = null;
   if (earlyEventsToProcess != null) {
      for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
         getApplicationEventMulticaster().multicastEvent(earlyEvent);
      }
   }
}

初始化非延迟加载单例

完成BeanFactory的初始化工作，其中包括ConversionService的设置，配置冻结以及非延迟加载的bean初始化工作。

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(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
   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);

//冻结所有的bean定义，说明注册的bean定义将不被修改或任何一步的处理。
   // Allow for caching all bean definition metadata, not expecting further changes.
   beanFactory.freezeConfiguration();

//初始化剩下但实例（非惰性）
   // Instantiate all remaining (non-lazy-init) singletons.
   beanFactory.preInstantiateSingletons();
}

分析代码

ConverisionService设置

上一章有自定义类转换器String转换为Date的方式。
在Spring中也提供了另一种方式Converter。具体使用可以网上查询。

冻结所有bean的定义。说明注册的bean定义将不被修改or进行任何进一步的处理

接口ConfigurableListableBeanFactory
具体实现是在DefaultListableBeanFactory

@Override
public void freezeConfiguration() {
   this.configurationFrozen = true;
   this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}

初始化非延迟加载

  • ApplicationContext实现的默认行为就是在启动时，将所有单例bean提取进行实例化。
  • 提前实例化意味着作为初始化过程中的一部分，ApplicationContext实例会创建并配置所有的单例bean
  • 在配置中的任何错误就会即刻被发现，这个实例化过程就是在finishBeanFactoryInitializatoin中完成的。

@Override
public void preInstantiateSingletons() throws BeansException {
   if (logger.isDebugEnabled()) {
      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)) {
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
               final FactoryBean factory = (FactoryBean) bean;
               boolean isEagerInit;
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                  isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                              ((SmartFactoryBean) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean) factory).isEagerInit());
               }
               if (isEagerInit) {
                  getBean(beanName);
               }
            }
         }
         else {
            getBean(beanName);
         }
      }
   }

   // 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((PrivilegedAction) () -> {
               smartSingleton.afterSingletonsInstantiated();
               return null;
            }, getAccessControlContext());
         }
         else {
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

 
  
finishRefresh
 
  
在Spring中提供了Lifecycle接口，其接口包含start/stop方法，实现此接口后Spring会保证在启动的时候调用start方法开始生命周期。
 并在关闭的时候调用stop方法来结束生命周期，通常用来配置后台程序，在启动后一直运行（如对MQ进行轮询），而ApplicationContext的初始化最后正是保证了这一个功能的实现。
 
  
protected void finishRefresh() {
   // Clear context-level resource caches (such as ASM metadata from scanning).
   clearResourceCaches();

   // Initialize lifecycle processor for this context.
   initLifecycleProcessor();

   // Propagate refresh to lifecycle processor first.
   getLifecycleProcessor().onRefresh();

   // Publish the final event.
   publishEvent(new ContextRefreshedEvent(this));

   // Participate in LiveBeansView MBean, if active.
   LiveBeansView.registerApplicationContext(this);
}

 
  
     
   
  • initLifecycleProcessor
    •  
  
 
  
当ApplicationContext启动or停止时，他会通过LifecycleProcessor来与所有声明的bean的周期做状态更新，而在LifecycleProcessor使用前首先需要初始化。
 
  
protected void initLifecycleProcessor() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
      this.lifecycleProcessor =
            beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
      if (logger.isDebugEnabled()) {
         logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
      }
   }
   else {
      DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
      defaultProcessor.setBeanFactory(beanFactory);
      this.lifecycleProcessor = defaultProcessor;
      beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
      if (logger.isDebugEnabled()) {
         logger.debug("Unable to locate LifecycleProcessor with name '" +
               LIFECYCLE_PROCESSOR_BEAN_NAME +
               "': using default [" + this.lifecycleProcessor + "]");
      }
   }
}

 
  
     
   
  • onRefresh
    •  
  
 
  
启动了所有实现了Lifecycle接口的bean
 
  
@Override
public void onRefresh() {
   startBeans(true);
   this.running = true;
}

private void startBeans(boolean autoStartupOnly) {
   Map lifecycleBeans = getLifecycleBeans();
   Map phases = new HashMap<>();
   lifecycleBeans.forEach((beanName, bean) -> {
      if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
         int phase = getPhase(bean);
         LifecycleGroup group = phases.get(phase);
         if (group == null) {
            group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
            phases.put(phase, group);
         }
         group.add(beanName, bean);
      }
   });
   if (!phases.isEmpty()) {
      List keys = new ArrayList<>(phases.keySet());
      Collections.sort(keys);
      for (Integer key : keys) {
         phases.get(key).start();
      }
   }
}


 
  
     
   
  • publishEvent
    •  
  
 
  
当完成ApplicationContext初始化的时候，要通过Spring中的事件发布机制发错ContextRefreshedEvent事件，以保证对应的监听器可以做一步的逻辑处理
 
  
@Override
public void publishEvent(ApplicationEvent event) {
   publishEvent(event, null);
}
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
   Assert.notNull(event, "Event must not be null");
   if (logger.isTraceEnabled()) {
      logger.trace("Publishing event in " + getDisplayName() + ": " + event);
   }

   // Decorate event as an ApplicationEvent if necessary
   ApplicationEvent applicationEvent;
   if (event instanceof ApplicationEvent) {
      applicationEvent = (ApplicationEvent) event;
   }
   else {
      applicationEvent = new PayloadApplicationEvent<>(this, event);
      if (eventType == null) {
         eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
      }
   }

   // Multicast right now if possible - or lazily once the multicaster is initialized
   if (this.earlyApplicationEvents != null) {
      this.earlyApplicationEvents.add(applicationEvent);
   }
   else {
      getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
   }

   // Publish event via parent context as well...
   if (this.parent != null) {
      if (this.parent instanceof AbstractApplicationContext) {
         ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
      }
      else {
         this.parent.publishEvent(event);
      }
   }
}


 
  
小结
 
  
     
   
  •  
    开始使用ApplicationContext的ClassPathXmlApplicationContext---------------ClassPathXmlApplicationContext->setConfigLocations获取路径----->refresh—>里面的层次功能
     
    •  
   
  •  
    以下是对refresh
     
    •  
   
  •  
    prepareRefresh-----可扩展initPropertySources,getEnvireonment().validateRequiredProperties
     
    •  
   
  •  
    obtainFreshBeanFactory-----加载beanFactory，实现beanFactory—> 父类AbstractRefreshableApplicationContext—>refreshBeanFactory-----实例化DefaultListableBeanFactory-----customizeBeanFactory,loadBeanDefinitions，定制bean和加载BeanDefintioin---------> loadBeanDefinitions-----初始化XmlBeanDefinitiionReader------->加载BeanDefintiion—>loadBeanDefinition
     
    •  
   
  •  
    prepareBeanFactoy—ApplicationContext的功能上的扩展在此展开---->SpEL语言支持—>增加属性编辑器------>添加ApplicationContextAwareProcessor处理器----实现Aware接口的bean初始化后取得对应的资源----->设置忽略依赖–对Aware忽略依赖注入---->注册依赖
     
    •  
   
  •  
    BeanPostProcessor --激活BeanPostProcessor---->invokeBeanFactoryPostProcessors（具体实现是在PostProcessorRegistrationDelegate中)-----这里区别以下对于BeanFactory和Bean的PostProcessor------注册BeanPostProcessor----->registerBeanPostProcessors
     
    •  
   
  •  
    国际化—initMessageSource
     
    •  
   
  •  
    监听------initApplicationEventMulticster—> SimpleApplicationEventMulticaster的multicastEvent----->注册 registerListeners
     
    •  
   
  •  
    初始化非延迟加载单例—包括了ConversionService转换器。冻结配置 freezeConfiguration。初始化非延迟加载 preInstantiateSingletons
     
    •  
   
  •  
    finishRefresh—通知刷新功能，启动lifecycle，发出ContextRefreshEvent通知别人—>finishRefresh---->initLifecycleProcessor—>onRefresh----->publishEvent
     
    •  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring)

        

            

                
    
                    
  • knife4j，微服务聚合Swagger文档
                        图书馆的小盆友
java开发相关微服务javamicroservices
                        
    前置知识我们将采用Nacos作为注册中心，Gateway作为网关，使用knife4j来生成API文档，对这些技术不了解的朋友可以看下下面的文章。SpringCloudGateway：新一代API网关服务SpringCloudAlibaba：Nacos作为注册中心和配置中心使用给Swagger换了个新皮肤，瞬间高大上了！应用架构我们理想的解决方案应该是这样的，网关作为API文档的统一入口，网关聚合所
    
                    
    • 
                    
  • 基于JAVA中的spring框架和jsp实现自然灾害论坛平台项目【附项目源码+论文说明】
                        大雄是个程序员
项目实践自然灾害论坛平台java项目源码spring毕业设计课程设计网页设计
                        
    摘要在上个世纪末期，也就是20世纪末，随着计算机技术的发展与进步和数据库方面的知识在互联网的大力运用，互联网技术以及网站技术在网上的大力推广，网上论坛（自然灾害论坛）也逐渐在网兴起，它的出现帮助了网上各种特定的群体进行一个在线的知识传递与信息的交流。本计算机自然灾害论坛设计，采用了JSP（JAVA）技术和MYSQL数据库开发，尝试实现了自然灾害论坛的基本功能以及帮助我们掌握了论坛技术的核心特点。该
    
                    
    • 
                    
  • Java架构师成长之路
                        hweiyu00
分享spring微服务springcloudjava
                        
    概述本教程主要从6个方面，全面讲解Java技术栈的知识。1.性能调优深入理解MySQL底层原理、索引逻辑，数据结构与算法。使用Explain进行优化分析MVCC原理剖析日志机制解析2.框架源码掌握Spring底层原理带你手写一个Spring解析IOC、AOP源码、以及事务原理3.并发编程剖析Java底层锁机制CAS、JUC工具使用、AQS源码分析以及并发的集合类的讲解4.分布式开发剖析分布式中使用
    
                    
    • 
                    
  • 穴位按摩培训系统Django-SpringBoot-php-Node.js-flask
                        QQ188083800
djangospringbootphp
                        
    目录具体实现截图技术栈介绍系统设计研究方法：设计步骤设计流程核心代码部分展示研究方法详细视频演示试验方案论文大纲源码获取/详细视频演示具体实现截图技术栈介绍本课题的研究方法和研究步骤基本合理，难度适中，本选题是学生所学专业知识的延续，符合学生专业发展方向，对于提高学生的基本知识和技能以及钻研能力有益。该学生能够在预定时间内完成该课题的设计。研究的选题立意明确，结构合理，研究内容充实，研究方法准确有
    
                    
    • 
                    
  • RocketMQ学习-Springboot整合RocketMQ
                        wechatt_fee1024
面试mavenspringbootjava
                        
    SpringBoot整合RocketMQ需要注意的是SpringBoot的starter集成包时，要注意版本。因为SpringBoot集成的RocketMQ的starter依赖由Spring社区提供，迭代比较快，版本之间的差异还是比较大的。可能版本不同，就导致使用的时候出现错误。maven依赖,直接把我的maven工程的配置放到这里了。普通消息maven工程创建我直接创建了一个空的maven工程，
    
                    
    • 
                    
  • 【商城实战(55)】商城数据库备份：策略与实操指南
                        奔跑吧邓邓子
商城实战商城实战数据库备份MySQL策略与实操
                        
    【商城实战】专栏重磅来袭！这是一份专为开发者与电商从业者打造的超详细指南。从项目基础搭建，运用uniapp、ElementPlus、SpringBoot搭建商城框架，到用户、商品、订单等核心模块开发，再到性能优化、安全加固、多端适配，乃至运营推广策略，102章内容层层递进。无论是想深入钻研技术细节，还是探寻商城运营之道，本专栏都能提供从0到1的系统讲解，助力你打造独具竞争力的电商平台，开启电商实战
    
                    
    • 
                    
  • fastjosn注册自定义序列化器
                        林发和
开发语言java
                        
    自定义序列化器：  importcom.alibaba.fastjson.serializer.JSONSerializer;  importcom.alibaba.fastjson.serializer.ObjectSerializer;  importorg.springframework.boot.actuate.health.Status;  importjava.io.IOExcepti
    
                    
    • 
                    
  • SpringBoot 整合security 实现自定义Token和clientId登录及退出(二)
                        .猫的树
springbootspringjava
                        
    接上一篇6.认证相关处理创建登录成功DemoAuthenticationSuccessHandler.java/***用户身份验证通过处理*/@Component@SuppressWarnings("all")publicclassDemoAuthenticationSuccessHandlerimplementsAuthenticationSuccessHandler{@Autowiredpri
    
                    
    • 
                    
  • rocketmq-client 4.3.0 在springboot中的使用
                        Myueye
JAVAjava
                        
    rocketmq-client4.3.0在springboot中的使用1、导入依赖2、配置文件属性3、编写配置类4、使用测试5、结果5.1RocketMQ后台显示5.2前端页面5.3后端后台1、导入依赖org.apache.rocketmqrocketmq-client4.3.02、配置文件属性mq.nameserverAdd=ip地址:9876mq.topic=top1(topic名称)mq.p
    
                    
    • 
                    
  • Spring Bean 的生命周期：从创建到销毁的完整解析
                        一点多余.
java开发语言
                        
    引言：为什么需要了解SpringBean的生命周期？在Spring框架中，Bean是应用程序的核心构建块，理解其生命周期对于开发高效、稳定的应用至关重要。根据2023年JetBrains开发者调查报告，超过75%的Java开发者使用Spring框架，而Bean的生命周期管理是Spring的核心特性之一。以下数据展示了Bean生命周期的重要性：90%的Spring性能问题与Bean的初始化或销毁不当
    
                    
    • 
                    
  • SpringAOP-基本概念-AOP入门程序-核心概念-通知类型-通知顺序-切入点表达式-连接点joinpoint-记录操作日志-获取当前登录员工
                        汐栊
java开发语言springmvc数据库
                        
    目录SpringAOP:AOP快速入门：AOP核心概念：AOP进阶：通知类型：注意事项：方法实现：@PointCutAOP通知顺序:执行顺序:不同切面类中,默认按照切面类的类名字母排序。用@Order(数字)加在切面类上来控制顺序AOP切入点表达式:切入点表达式-execution：切入点表达式-@annotation:可以使用通配符描述切入点:AOP连接点:AOP案例:将案例中增,删,改相关接口
    
                    
    • 
                    
  • Spring事务失效的常见场景
                        红云梦
springjava数据库
                        
    1事务1.1数据库事务作为单个逻辑工作单元执行的一系列操作，要么完全执行，要么完全不执行1.2事务的四大特性（ACID）原子性(Atomicity)：要么成功，要么失败。一个事务内的所有SQL语句同步执行（依靠undo.log日志保证）一致性(Consistency)：事务前后总量不变，数据库完整性约束没有被破坏隔离性(Isolation)：一个事务执行不被其他事务干扰（锁+MVCC）持久性(Du
    
                    
    • 
                    
  • 基于 MySQL 和 Spring Boot 的在线论坛管理系统设计与实现
                        城南|阿洋-计算机从小白到大神
mysqlspringboot数据库
                        
    markdownCopy✌全网粉丝20W+,csdn特邀作者、博客专家、CSDN[新星计划]导师、java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java、pyhton、机器学习技术领域和毕业项目实战✌哈喽兄弟们，好久不见哦～最近整理了一下之前写过的一些小项目/毕业设计。发现还是有很多存货的，想一想既然放在电脑里面也吃灰，那么还不如分享出去，没准还可以帮助到
    
                    
    • 
                    
  • [开题报告]Springboot高校图书管理系统设计与实现lq627计算机毕业设计
                        卓越计算机毕设
课程设计
                        
    本项目包含程序+源码+数据库+LW+调试部署环境，文末可获取一份本项目的java源码和数据库参考。开题报告研究背景：随着高校图书馆的规模不断扩大和信息化程度的提高，传统的手工管理方式已经无法满足日益增长的图书馆资源管理需求。图书管理系统的设计与实现成为了解决这一问题的关键。通过引入计算机技术和信息管理系统，可以提高图书馆的管理效率和服务质量，为读者提供更便捷、高效的借阅体验。研究意义：图书管理系统
    
                    
    • 
                    
  • MATH2110 - STATISTICS 3
                        W_X_99515681
开发语言
                        
    TheUniversityofNottinghamSCHOOLOFMATHEMATICALSCIENCESSPRINGSEMESTERSEMESTER2025MATH2110-STATISTICS3Coursework1Deadline:3pm,Friday14/3/2025Yourneat,clearly-legiblesolutionsshouldbesubmittedelectronical
    
                    
    • 
                    
  • Spring Data JPA 的分页魔法：Pageable vs PageRequest，谁才是真正的“分页王”？✨
                        小丁学Java
SpringDataJPA数据库
                        
    SpringDataJPA的分页魔法：PageablevsPageRequest，谁才是真正的“分页王”？嘿，各位技术探险家！今天我们要解锁SpringDataJPA的分页秘籍，聊聊Pageable和PageRequest这对“分页双人组”的爱恨情仇！从它们的关系到使用场景，再到一个让我抓狂的参数陷阱，这篇博客带你从迷雾走向光明，还有流程图助阵，快跟我一起跳进这个技术冒险吧！第一幕：分页的“魔法钥
    
                    
    • 
                    
  • Spring容器初始化扩展点：ApplicationContextInitializer
                        web14786210723
面试学习路线阿里巴巴springjava后端
                        
    目录一、什么是ApplicationContextInitializer？1、核心作用2、适用场景二、ApplicationContextInitializer的使用方式1、实现ApplicationContextInitializer接口2、注册初始化器三、ApplicationContextInitializer的执行时机四、实际应用案例1、动态设置环境变量2、注册自定义的Bean定义五、注意
    
                    
    • 
                    
  • 【Docker系列四】Docker 网络
                        Kwan的解忧杂货铺@新空间代码工作室
s4Docker系列docker网络容器
                        
    欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
    
                    
    • 
                    
  • Axios 和 跨域 这两个概念
                        PLJJ685
前后端分离的仓库管理系统前端
                        
    1.Axios是什么？Axios是一个用于发送网络请求的工具，类似于浏览器自带的fetch，但更强大、更易用。在前端（Vue）中，我们通常用Axios来向后端（SpringBoot）请求数据。举个例子：假设你在一个仓储系统中，前端需要从后端获取商品库存信息。这时，前端就可以用Axios发送一个请求，比如：axios.get('/api/inventory').then(response=>{con
    
                    
    • 
                    
  • SpringBoot集成Flink-CDC，实现对数据库数据的监听
                        rkmhr_sef
面试学习路线阿里巴巴springbootflink数据库
                        
    一、什么是CDC？CDC是ChangeDataCapture（变更数据获取）的简称。核心思想是，监测并捕获数据库的变动（包括数据或数据表的插入、更新以及删除等），将这些变更按发生的顺序完整记录下来，写入到消息中间件中以供其他服务进行订阅及消费。二、Flink-CDC是什么？CDCConnectorsforApacheFlink是一组用于ApacheFlink的源连接器，使用变更数据捕获(CDC)从
    
                    
    • 
                    
  • springBoot 和springCloud 版本对应关系
                        m0_74824894
面试学习路线阿里巴巴springbootspringcloud后端
                        
    请求下面链接：拿到的json数据，格式化https://start.spring.io/actuator/info[这里是图片001]https://start.spring.io/actuator/info云原生脚手架CloudNativeAppInitializer(aliyun.com)[这里是图片002]https://start.aliyun.com/idea阿里云脚手架插件：Aliba
    
                    
    • 
                    
  • SpringBoot项目中读取resource目录下的文件（六种方法）
                        web18285997089
面试学习路线阿里巴巴springbootpythonpycharm
                        
    文章目录一、先获取绝对路径再读取文件(jar包里会获取不到)方法一：类加载器的getResource().getPath()获取目录路径方法二：类加载器的getResource().getPath()获取文件路径二、直接获取文件流（jar包可用）方法三：ClassLoader对象的getResourceAsStream()方法四：Class对象的getResourceAsStream()三、使用封
    
                    
    • 
                    
  • SpringBoot分布式架构下字典表设计与实战应用
                        潘多编程
springboot分布式架构
                        
    在分布式系统中，字典表作为基础数据的核心载体，其设计合理性直接影响系统的扩展性和维护效率。本文将结合具体代码实例，深入讲解分布式环境下字典表的设计方案与实现细节。一、分布式环境下的字典表挑战数据一致性要求：多服务节点间的字典数据同步高并发访问压力：基础数据的频繁读取需求动态更新需求：业务运行时字典数据的热更新能力多级缓存策略：本地缓存与分布式缓存的协同工作二、技术方案设计架构图：[Client]-
    
                    
    • 
                    
  • Apache大数据旭哥优选大数据选题
                        Apache大数据旭
大数据定制选题javahadoopspark开发语言ideahive数据库架构
                        
    定制旭哥服务，一对一，无中介包安装+答疑+售后态度和技术都很重要定制按需求做要求不高就实惠一点定制需提前沟通好怎么做，这样才能避免不必要的麻烦python、flask、Django、mapreduce、mysqljava、springboot、vue、echarts、hadoop、spark、hive、hbase、flink、SparkStreaming、kafka、flume、sqoop分析+推
    
                    
    • 
                    
  • 基于springboot的在线点餐系统
                        爱编程的小哥
java毕设springboot后端javavue
                        
    全栈在线点餐系统架构解析|SpringBoot+ElementUI后台管理实战（附高并发订单处理方案）一、系统全景透视基于五张效果图分析，该系统是餐饮行业全流程数字化解决方案，采用SpringBoot+MyBatisPlus+Vue2+ElementUI技术栈，实现用户端订餐与商家端管理的双向闭环。通过RBAC权限控制+订单状态机+实时库存预警三大核心机制，支持日均万级订单处理，覆盖从用户选餐、支
    
                    
    • 
                    
  • 基于springboot的社区团购系统设计
                        Olivia-gogogo
springboot后端java
                        
    一、引言在当今数字化时代，信息技术正以前所未有的速度渗透到社会的各个领域，深刻地改变着人们的生活和工作方式。教育领域也不例外，随着高等教育的普及和招生规模的不断扩大，大学生入学审核工作面临着越来越大的挑战。传统的人工入学审核方式已难以满足现代教育管理的需求，暴露出诸多弊端。传统人工入学审核方式效率低下。在每年的招生季，高校招生工作人员需要面对大量的入学申请材料，这些材料不仅数量庞大，而且种类繁多，
    
                    
    • 
                    
  • Spring Boot 项目 90% 存在这 15 个致命漏洞，你的代码在裸奔吗？
                        风象南
原创随笔javaspringboot后端web安全系统安全
                        
    文章首发公众号【风象南】SpringBoot作为一款广泛使用的Java开发框架，虽然为开发者提供了诸多便利，但也并非无懈可击，其安全漏洞问题不容忽视。本文将深入探讨SpringBoot常见的安全漏洞类型、产生原因以及相应的解决方案，帮助开发者更好地保障应用程序的安全。1.SQL注入漏洞漏洞描述：当应用程序使用用户输入的数据来构建SQL查询时，如果没有进行适当的过滤或转义，攻击者就可以通过构造恶意的
    
                    
    • 
                    
  • 【深入理解 SpringBoot3】第一弹：SpringBoot3 快速入门
                        敖云岚
springboot后端java
                        
    一、SpringBoot是什么SpringBoot帮我们简单、快速地创建一个独立的、生产级别的Spring应用大多数SpringBoot应用只需要编写少量配置即可快速整合Spring平台以及第三方技术。特性：直接嵌入Tomcat、Jetty或Undertow（无需部署war包）提供可选的starter（场景启动器）简化应用的整合实现按需的自动配置Spring以及第三方库（约定大于配置）：appli
    
                    
    • 
                    
  • springboot基于bs 架构的母婴用户商城全程服务管理系统(源码+lw+部署文档+讲解等)
                        源码哆哆V+ymhydo
Java毕设优质源码springboot架构后端
                        
    具体实现截图技术栈后端框架SpringBoot采用springboot作为后台的框架，java框架具有简化配置和开发的效率。Spring框架目前是很多java开发者的首选框架，Spring主要有两大功能，控制反转和面向切面的编程。控制反转（IOC）可以实现代码的依赖注入，减少代码的耦合性，大大提高了软件质量，面向切面编程（AOP）主要是应用动态代理的技术对代码逻辑进行分离，可以实现对代码的重用，适
    
                    
    • 
                    
  • SpringBoot接口防抖(防重复提交)，接口幂等性，轻松搞定
                        web18285482512
面试学习路线阿里巴巴springboot后端java
                        
    啥是防抖？所谓防抖，一是防用户手抖，二是防网络抖动。在Web系统中，表单提交是一个非常常见的功能，如果不加控制，容易因为用户的误操作或网络延迟导致同一请求被发送多次，进而生成重复的数据记录。要针对用户的误操作，前端通常会实现按钮的loading状态，阻止用户进行多次点击。而对于网络波动造成的请求重发问题，仅靠前端是不行的。为此，后端也应实施相应的防抖逻辑，确保在网络波动的情况下不会接收并处理同一请
    
                    
    • 
                                
  • web报表工具FineReport常见的数据集报错错误代码和解释
                                    老A不折腾
web报表finereport代码可视化工具
                                    
    在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 
  
NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 
NS_LayerReport_MultiDs=错误代码
    
                                
    • 
                                
  • Java的WeakReference与WeakHashMap
                                    bylijinnan
java弱引用
                                    
    首先看看 WeakReference 
 
wiki 上 Weak reference 的一个例子： 
 
 

	public class ReferenceTest {
	public static void main(String[] args) throws InterruptedException {
 
            WeakReference r = new Wea
    
                                
    • 
                                
  • Linux——（hostname）主机名与ip的映射
                                    eksliang
linuxhostname
                                    
    一、 什么是主机名 
无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的； 
主机名是用于什么的呢？ 
答：在一个局域网中，每台机器都有一个主
    
                                
    • 
                                
  • oracle 常用技巧
                                    18289753290

                                    
    oracle常用技巧   ①复制表结构和数据     create table  temp_clientloginUser   as     select distinct userid from tbusrtloginlog   ②仅复制数据   如果表结构一样   insert into  mytable  select  * &nb
    
                                
    • 
                                
  • 使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException
                                    酷的飞上天空
exception
                                    
    有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
    
                                
    • 
                                
  • IT系统分析师如何学习大数据
                                    蓝儿唯美
大数据
                                    
    我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系 统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
    
                                
    • 
                                
  • spring学习——简介
                                    a-john
spring
                                    
    Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 
 
为了降低Java开发的复杂性，
    
                                
    • 
                                
  • 自定义颜色的xml文件
                                    aijuans
xml
                                    
    <?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
    
                                
    • 
                                
  • 运营到底是做什么的？
                                    aoyouzi
运营到底是做什么的？
                                    
    文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
    
                                
    • 
                                
  • js面向对象类和对象
                                    百合不是茶
js面向对象函数创建类和对象
                                    
    接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言 但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下  ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似 
  
下面介绍一些js的类和对象的创建的技术 
  
一:类和对
    
                                
    • 
                                
  • web.xml之资源管理对象配置 resource-env-ref
                                    bijian1013
javaweb.xmlservlet
                                    
    resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 
<resource-env-ref>
    <resource-env-ref-name>资源名</resource-env-ref-name>
    <resource-env-ref-type>查找资源时返回的资源类
    
                                
    • 
                                
  • Create a composite component with a custom namespace
                                    sunjing

                                    
    https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace 
  
When you developed a composite component the namespace you would be seeing would 
    
                                
    • 
                                
  • 【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter
                                    bit1129
mongodb
                                    
     一、复本集为什么要加入Arbiter这个角色   回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。   什么是Artiber？   An arbiter does 
not have a copy of data set and 
cannot become a primary. Replica sets may have arbiters to add a 
    
                                
    • 
                                
  • Javascript开发笔记
                                    白糖_
JavaScript
                                    
     
 获取iframe内的元素 
 
通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
    
                                
    • 
                                
  • Web浏览器Chrome打开一段时间后，运行alert无效
                                    bozch
Webchormealert无效
                                    
    今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。 
试了试其他浏览器，发现都是没有问题的。 
开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。 
这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了 就关闭浏览器重启。 
  
结果就好了，这也太怪异了。难道是cho
    
                                
    • 
                                
  • 编程之美-高效地安排会议 图着色问题 贪心算法
                                    bylijinnan
编程之美
                                    
    

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class GraphColoringProblem {

	/**编程之美 高效地安排会议 图着色问题 贪心算法
	 * 假设要用很多个教室对一组
    
                                
    • 
                                
  • 机器学习相关概念和开发工具
                                    chenbowen00
算法matlab机器学习
                                    
    基本概念： 
机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。 
它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。 
 
开发工具 
M
    
                                
    • 
                                
  • [宇宙经济学]关于在太空建立永久定居点的可能性
                                    comsci
经济
                                    
     
       大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 
 
       所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
    
                                
    • 
                                
  • oracle 11g database control 证书错误
                                    daizj
oracle证书错误oracle 11G 安装
                                    
    oracle 11g database control 证书错误  
 
win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面 
 
解决办法： 
 
是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
    
                                
    • 
                                
  • Java I/O之用FilenameFilter实现根据文件扩展名删除文件
                                    游其是你
FilenameFilter
                                    
    在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。 
在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16 
    
                                
    • 
                                
  • C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例
                                    dcj3sjt126com
carray
                                    
    # include <stdio.h>

int main(void)
{
	
	int a[5] = {1, 2, 3, 4, 5};
		//a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4]
	
	int i;

	for (i=0; i<5; ++i)
		printf("%d\n",
    
                                
    • 
                                
  • PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。 就是 唯一 且 不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引
                                    dcj3sjt126com
primary
                                    
    PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。 就是 唯一 且 不能为空。INDEX 索引，普通的UNIQUE 唯一索引。 不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号   INT会员姓名  
    
                                
    • 
                                
  • java集合辅助类 Collections、Arrays
                                    shuizhaosi888
CollectionsArraysHashCode
                                    
      
Arrays、Collections 
  
1 ）数组集合之间转换 
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    } 
     a）Arrays.asL
    
                                
    • 
                                
  • Spring Security（10）——退出登录logout
                                    234390216
logoutSpring Security退出登录logout-urlLogoutFilter
                                    
           要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
    
                                
    • 
                                
  • 透过源码学前端 之 Backbone 三 Model
                                    逐行分析JS源代码
backbone源码分析js学习
                                    
    Backbone 分析第三部分  Model 
概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里， 
但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件， 
如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。 
    
                                
    • 
                                
  • SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter
                                    乒乓狂魔
springMVC
                                    
    这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 
 
HttpMessageConverter接口介绍： 
 

public interface HttpMessageConverter<T> {

	/**
	 * Indicate
    
                                
    • 
                                
  • 分布式基础知识和算法理论
                                    bluky999
算法zookeeper分布式一致性哈希paxos
                                    
       
分布式基础知识和算法理论 
BY [email protected] 
本文永久链接：http://nodex.iteye.com/blog/2103218 
  
在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
    
                                
    • 
                                
  • Android Studio的.gitignore以及gitignore无效的解决
                                    bell0901
androidgitignore
                                    
    　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 
　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了 
　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store 
    
                                
    • 
                                
  • 成为高级程序员的10个步骤
                                    tomcat_oracle
编程
                                    
    What 
软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 
  
Why 
 
  得到更多的报酬！因为你的薪水会随着你水平的提高而增加  
  提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进  
  历经更大的挑战。随着你的成长，各种影响力也会提高。  
    
                                
    • 
                                
  • mongdb在linux下的安装
                                    xtuhcy
mongodblinux
                                    
    一、查询linux版本号： 
lsb_release -a  
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa
    
                                
    •