@Configuration注解 -【Spring底层原理】

最新推荐文章于 2024-05-31 11:42:39 发布
最新推荐文章于 2024-05-31 11:42:39 发布
阅读量880 收藏 21
点赞数 22
分类专栏： 程序员 文章标签： spring windows java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83817653/article/details/137095890
版权

BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;

registryProcessor.postProcessBeanDefinitionRegistry(registry);

registryProcessors.add(registryProcessor);

} else {

regularPostProcessors.add(postProcessor);

}

}

currentRegistryProcessors = new ArrayList();

postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

String[] var16 = postProcessorNames;

var9 = postProcessorNames.length;

int var10;

String ppName;

// 遍历postProcessorNames

for(var10 = 0; var10 < var9; ++var10) {

ppName = var16[var10];

if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

processedBeans.add(ppName);

}

}

sortPostProcessors(currentRegistryProcessors, beanFactory);

registryProcessors.addAll(currentRegistryProcessors);

// 解析配置类，为配置中的bean定义生成对应beanDefinition,并注入到registry的beanDefinitionMap

invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());

currentRegistryProcessors.clear();

postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

var16 = postProcessorNames;

var9 = postProcessorNames.length;

for(var10 = 0; var10 < var9; ++var10) {

ppName = var16[var10];

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, beanFactory.getApplicationStartup());

currentRegistryProcessors.clear();

boolean reiterate = true;

while(reiterate) {

reiterate = false;

postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

String[] var19 = postProcessorNames;

var10 = postProcessorNames.length;

for(int var26 = 0; var26 < var10; ++var26) {

String ppName = var19[var26];

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, beanFactory.getApplicationStartup());

currentRegistryProcessors.clear();

}

// 调用ConfigurationClassPostProcessor#postProcessBeanFactory增强配置类

// 通过cglib生成增强类,加载到jvm内存

// 设置beanDefinition的beanClass为增强类,让@Bean生成的bean是单例

invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);

invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);

} else {

invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);

}

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

regularPostProcessors = new ArrayList();

registryProcessors = new ArrayList();

currentRegistryProcessors = new ArrayList();

postProcessorNames = postProcessorNames;

int var20 = postProcessorNames.length;

String ppName;

for(var9 = 0; var9 < var20; ++var9) {

ppName = postProcessorNames[var9];

if (!processedBeans.contains(ppName)) {

if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {

registryProcessors.add(ppName);

} else {

currentRegistryProcessors.add(ppName);

}

}

}

sortPostProcessors(regularPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);

List orderedPostProcessors = new ArrayList(registryProcessors.size());

Iterator var21 = registryProcessors.iterator();

while(var21.hasNext()) {

String postProcessorName = (String)var21.next();

orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

}

sortPostProcessors(orderedPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);

List nonOrderedPostProcessors = new ArrayList(currentRegistryProcessors.size());

Iterator var24 = currentRegistryProcessors.iterator();

while(var24.hasNext()) {

ppName = (String)var24.next();

nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

}

invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);

beanFactory.clearMetadataCache();

}

这里和@Configuration注解相关的方法是invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);，继续跟踪，进入源码查看：

【PostProcessorRegistrationDelegate中invokeBeanFactoryPostProcessors方法】

private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

Iterator var2 = postProcessors.iterator();

while(var2.hasNext()) {

BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var2.next();

StartupStep var10000 = beanFactory.getApplicationStartup().start(“spring.context.bean-factory.post-process”);

postProcessor.getClass();

StartupStep postProcessBeanFactory = var10000.tag(“postProcessor”, postProcessor::toString);

// 调用ConfigurationClassPostProcessor#postProcessBeanFactory增强配置类

postProcessor.postProcessBeanFactory(beanFactory);

postProcessBeanFactory.end();

}

}

继续跟踪postProcessor.postProcessBeanFactory(beanFactory);，进入源码查看，发现是一个接口，咱们找到和@Configuration相关的，也就是截图中框出来的 ，查看源码：

image-20210115154241215

image-20210115154241215

【ConfigurationClassPostProcessor类中postProcessBeanFactory方法】

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

int factoryId = System.identityHashCode(beanFactory);

if (this.factoriesPostProcessed.contains(factoryId)) {

throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + beanFactory);

} else {

this.factoriesPostProcessed.add(factoryId);

if (!this.registriesPostProcessed.contains(factoryId)) {

this.processConfigBeanDefinitions((BeanDefinitionRegistry)beanFactory);

}

// 进行代理，为@Configuration注解的类生成增强类

this.enhanceConfigurationClasses(beanFactory);

beanFactory.addBeanPostProcessor(new ConfigurationClassPostProcessor.ImportAwareBeanPostProcessor(beanFactory));

}

}

该方法会去判断我们的bean工厂当中是否有bean需要进行cglib代理，并在enhanceConfigurationClasses(beanFactory)方法中进行代理，为@Configuration注解的类生成增强类，继续跟踪，点进enhanceConfigurationClasses，如下：

【ConfigurationClassPostProcessor类中enhanceConfigurationClasses方法】

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {

StartupStep enhanceConfigClasses = this.applicationStartup.start(“spring.context.config-classes.enhance”);

Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap();

String[] var4 = beanFactory.getBeanDefinitionNames();

int var5 = var4.length;

for(int var6 = 0; var6 < var5; ++var6) {

String beanName = var4[var6];

BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);

// 在ConfigurationClassUtils中标记是Full @Configuration还是lite @Bean mode

Object configClassAttr = beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);

MethodMetadata methodMetadata = null;

if (beanDef instanceof AnnotatedBeanDefinition) {

methodMetadata = ((AnnotatedBeanDefinition)beanDef).getFactoryMethodMetadata();

}

if ((configClassAttr != null || methodMetadata != null) && beanDef instanceof AbstractBeanDefinition) {

AbstractBeanDefinition abd = (AbstractBeanDefinition)beanDef;

if (!abd.hasBeanClass()) {

try {

abd.resolveBeanClass(this.beanClassLoader);

} catch (Throwable var13) {

throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), var13);

}

}

}

// 1.判断是否是全类注解

if (“full”.equals(configClassAttr)) {

if (!(beanDef instanceof AbstractBeanDefinition)) {

throw new BeanDefinitionStoreException(“Cannot enhance @Configuration bean definition '” + beanName + “’ since it is not stored in an AbstractBeanDefinition subclass”);

}

if (this.logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {

this.logger.info(“Cannot enhance @Configuration bean definition '” + beanName + “’ since its singleton instance has been created too early. The typical cause is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor return type: Consider declaring such methods as ‘static’.”);

}

// 2.是全注解则将beandefinition放入map中

configBeanDefs.put(beanName, (AbstractBeanDefinition)beanDef);

}

}

if (!configBeanDefs.isEmpty() && !IN_NATIVE_IMAGE) {

ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();

Iterator var15 = configBeanDefs.entrySet().iterator();

// 3.然后遍历这个map

while(var15.hasNext()) {

Entry<String, AbstractBeanDefinition> entry = (Entry)var15.next();

AbstractBeanDefinition beanDef = (AbstractBeanDefinition)entry.getValue();

beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);

Class<?> configClass = beanDef.getBeanClass();

// 4.进行cglib代理，为@Configuration注解的类生成增强类

Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);

if (configClass != enhancedClass) {

if (this.logger.isTraceEnabled()) {

this.logger.trace(String.format(“Replacing bean definition ‘%s’ existing class ‘%s’ with enhanced class ‘%s’”, entry.getKey(), configClass.getName(), enhancedClass.getName()));

}

// 再通过beanDef.setBeanClass(enhancedClass)修改beanDefinition的BeanClass属性，

// 在bean实例化阶段，会利用反射技术将beanClass属性对应的类实例化出来

// 所以最终实例化出来的@Configuration bean是一个代理类的实例

beanDef.setBeanClass(enhancedClass);

}

}

enhanceConfigClasses.tag(“classCount”, () -> {

return String.valueOf(configBeanDefs.keySet().size());

}).end();

} else {

enhanceConfigClasses.end();

}

}

在ConfigurationClassUtils类中声明了是Full @Configuration还是lite @Bean mode，可以看看源码：

【ConfigurationClassUtils类中checkConfigurationClassCandidate方法】

Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());

// 如果存在@Configuration注解,则为BeanDefinition设置configurationClass属性为full

if (config != null && !Boolean.FALSE.equals(config.get(“proxyBeanMethods”))) {

beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, “full”);

} else {

if (config == null && !isConfigurationCandidate(metadata)) {

return false;

}

// 如果没有@Configuration注解或者有Component,ComponentScan,Import,ImportResource 注解中的任意一个,

// 或者存在 被@bean 注解的方法,则返回true.

// 则设置configurationClass属性为lite

beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, “lite”);

}

Integer order = getOrder(metadata);

if (order != null) {

beanDef.setAttribute(ORDER_ATTRIBUTE, order);

}

跟踪到这里，基本上就比较明朗了，可以得到我们想要的答案

  1. 在ConfigurationClassUtils类中的checkConfigurationClassCandidate标记是Full @Configuration还是lite @Bean mode
  1. 通过"full".equals(configClassAttr)判断是否是全类注解
  1. 是全注解则将beandefinition放入map中configBeanDefs.put
  1. 遍历这个map
  1. 使用cglib技术为配置类生成一个enhancedClass
  1. 通过enhancer.enhance进行cglib代理，为@Configuration注解的类生成增强类
  1. 再通过beanDef.setBeanClass(enhancedClass)修改beanDefinition的BeanClass属性，在bean实例化阶段，会利用反射技术将beanClass属性对应的类实例化出来，所以最终实例化出来的@Configuration bean是一个代理类的实例

使用了@Configuration注解的类，属于Full @Configuration。@Configuration类允许通过调用同一类中的其他@Bean方法来定义bean之间的依赖关系，保证@Bean的对象作用域受到控制，避免多例。@Configuration类中的@Bean地方会被CGLIB进行代理。Spring会拦截该方法的执行，在默认单例情况下，容器中只有一个Bean，所以我们多次调用user()方法，获取的都是同一个对象。

对于@Configuration注解的类中@Bean标记的方法，返回的都是一个bean，在增强的方法中，Spring会先去容器中查看一下是否有这个bean的实例了，如果有了的话，就返回已有对象，没有的话就创建一个，然后放到容器中。

是如何进行代理的，咱们还可以继续跟踪：点开enhancer.enhance，进入ConfigurationClassEnhancer类，在这个类中会去执行cglib代理类中的代理方法，如下：

【ConfigurationClassEnhancer类中static静态方法】

static {

CALLBACKS = new Callback[]{new ConfigurationClassEnhancer.BeanMethodInterceptor(),

new ConfigurationClassEnhancer.BeanFactoryAwareMethodInterceptor(), NoOp.INSTANCE};

CALLBACK_FILTER = new ConfigurationClassEnhancer.ConditionalCallbackFilter(CALLBACKS);

logger = LogFactory.getLog(ConfigurationClassEnhancer.class);

objenesis = new SpringObjenesis();

}

cglib代理主要就是callBacks中的方法，点进去可以看到是一个接口，其中有一个实现类就是和cglib相关的

image-20210115201141656

image-20210115201141656

四、总结

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（资料价值较高，非无偿）

img

面试资料整理汇总

成功从小公司跳槽进蚂蚁定级P7，只因刷了七遍这些面试真题

成功从小公司跳槽进蚂蚁定级P7，只因刷了七遍这些面试真题

这些面试题是我朋友进阿里前狂刷七遍以上的面试资料，由于面试文档很多，内容更多，没有办法一一为大家展示出来，所以只好为大家节选出来了一部分供大家参考。

面试的本质不是考试，而是告诉面试官你会做什么，所以，这些面试资料中提到的技术也是要学会的，不然稍微改动一下你就凉凉了

在这里祝大家能够拿到心仪的offer！
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！**

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（资料价值较高，非无偿）

img

面试资料整理汇总

[外链图片转存中…(img-fqeowZnt-1711575637975)]

[外链图片转存中…(img-YyKpPxHa-1711575637975)]

这些面试题是我朋友进阿里前狂刷七遍以上的面试资料，由于面试文档很多，内容更多，没有办法一一为大家展示出来，所以只好为大家节选出来了一部分供大家参考。

面试的本质不是考试，而是告诉面试官你会做什么，所以，这些面试资料中提到的技术也是要学会的，不然稍微改动一下你就凉凉了

在这里祝大家能够拿到心仪的offer！
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

2401_83817653
关注
  • 22
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
@Configuration注解 -【Spring底层原理】，设计思想解读开源框架
2401_83977580的博客
04-02 911
笔者已经把面试题和答案整理成了面试专题文档转存中…(img-mFqT4hmH-1712066217655)][外链图片转存中…(img-hNW8tyrV-1712066217656)][外链图片转存中…(img-S4ovYOPg-1712066217657)]既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
Spring注解 - 52注解 - 原稿笔记
08-09
注解包含: 拦截器 , 过滤器 , 序列化 , @After , @AfterReturning , @AfterThrowing , @annotation , @Around , @Aspect , @Autowired , @Bean , @Before , @Component , @ComponentScan , @ComponentScans , @...
@Profile注解 -【Spring底层原理】
ONESTARの博客
03-17 831
目录 @Profile注解 -【Spring底层原理】 一、注解用法 二、实例分析 三、源码追踪 四、总结 一、注解用法 在我们开发开发测试部署当中，有不同的环境，比如有：开发环境、测试环境、上产环境，不同的环境有不同的组件，这听着怎么那么像springboot中的多环境配置呢？今天，咱们来看看在spring中是如何实现的。 为了多环境开发，Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能，比如数据源组件的配置，不同开发环境连接的数据源可能会不同，就可以使用@P
@Conditional注解 -【Spring底层原理】
ONESTARの博客
02-25 798
案例已上传GitHub，欢迎star以鼓励：https://github.com/oneStarLR/spring-annotation 一、注解用法 @Conditional是Spring4新提供的注解，也是用来注册bean的，作用如下： 按照一定的条件进行判断，满足条件的给容器注册bean 从源码中我们可以看到，可以作用在类和方法上 需要传入一个Class数组，并继承Condition接口 // 可以作用在类上，也可以作用在方法上 @Target({ElementType.TYPE.
@Import注解 -【Spring底层原理】
2401_84048542的博客
05-03 909
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
@ComponentScan注解 -【Spring底层原理】
ONESTARの博客
01-21 1585
目录 一、注解用法 1. 背景知识 2. @ComponentScan注解作用 二、实例分析 1. excludeFilters=Filter[ ] 2. includeFilters=filter[ ] 3. FilterType.CUSTOM 三、源码追踪 案例已上传GitHub，欢迎star：https://github.com/oneStarLR/spring-annotation 一、注解用法 1. 背景知识 什么是组件？ 组件也是抽象的概念，可以理解为一些符.
@Autowired注解 -【Spring底层原理】
ONESTARの博客
03-15 1167
目录 一、概述 二、实例分析 三、源码追踪 四、总结 一、概述 【1】注解用法 根据@Autowired注解的源码，可以看到该注解可以作用在构造器、参数、方法、属性，都是从容器中获取参数组件的值 标注在方法上：@Bean+方法参数，参数从容器中获取，默认不写@Autowired效果是一样的，都能自动装配 标注在构造器上：如果组件上只有一个有参构造，这个有参构造的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取 标注在参数位置 标注在属性位置 @Target(.
【Spring面试全家桶】Spring之@Configuration底层原理详解
Java程序员廖志伟
06-21 672
生成代理对象后，Spring框架会将该对象注册到IoC容器中。@ConfigurationClassParser类是Spring框架内部的一个类，它用于解析@Configuration注解，扫描其中所有的@Bea注解标记的方法，并为这些方法生成对应的BeanDefinition对象，然后将这些对象注册到IoC容器中。它的主要功能是扫描@Configuration注解所标记的类，并解析其中所有的@Bea注解标记的方法，为这些方法生成对应的BeanDefinition对象，并将这些对象注册到IoC容器中。
@EventListener注解 -【Spring底层原理】
ONESTARの博客
03-25 1673
目录 一、注解用法 二、实例分析 三、源码分析 四、总结 上篇我们讲到实现事件监听可以使用实现ApplicationListener接口Spring中ApplicationListener -【Spring底层原理】，如果有多个方法需要监听事件，那岂不是每个方法都要放在类中实现ApplicationListener接口，这样并不是很方便，所以spring为我们提供了另外一种方式实现事件监听：使用@EventListener注解 一、注解用法 注解源码如下，有如下作用： 可以...
刨析Spring的@Configuration注解属性proxyBeanMethods原理
flyfhj的博客
02-02 3382
Spring框架中有一个出现频次很高的注解@Configuration，特别是在SpringBoot的spring-boot-autoconfigure包中，可以发现每个配置类基本都会加上@Configuration(proxyBeanMethods=false)注解(注：Spring 5.2+)，其中proxyBeanMethods属性起到什么作用呢？今天我们就通过源码探究它的底层原理。
Spring @Configuration注解及配置方法
08-19
主要介绍了Spring @Configuration注解及配置方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Springboot @Configuration @bean注解作用解析
08-25
主要介绍了springboot @Configuration @bean注解作用解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
详解配置类为什么要添加@Configuration注解
08-19
主要介绍了详解配置类为什么要添加@Configuration注解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring-boot-configuration-processor-2.5.6-API文档-中英对照版.zip
07-14
赠送jar包：spring-boot-configuration-processor-2.5.6.jar； 赠送原API文档：spring-boot-configuration-processor-2.5.6-javadoc.jar； 赠送源代码：spring-boot-configuration-processor-2.5.6-sources.jar； ...
springboot mqtt收发消息
最新发布
qq_34874784的博客
05-31 335
​在Spring Boot中，可以使用MQTT协议来收发消息。这样，就可以使用Spring Boot和MQTT协议来收发消息了。5. 使用MQTT消息接收和发送服务。3. 创建MQTT消息接收服务。4. 创建MQTT消息发送服务。2. 配置MQTT连接工厂。
SpringBoot集成腾讯COS流程
weixin_67727883的博客
05-30 252
SpringBoot集成腾讯COS流程
SpringBoot 异步编程
凤凰的博客
05-29 1124
使用@Async注解，在默认情况下用的是线程池，该线程池不是真正意义上的线程池。使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发= null?//判断是否开启限流，默认为否//执行前置操作，进行限流} else {//未限流的情况，执行线程任务//不断创建线程= null?//创建线程//指定线程名，task-1，task-2...
@configuration注解原理
10-10
@Configuration注解的原理是基于Java的注解处理器和Spring的IoC容器。当Spring容器扫描到带有@Configuration注解的类时，会使用Java的反射机制来解析配置类，读取其中的Bean定义和配置信息。然后，Spring容器会将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值