Spring Bean循环依赖问题及解决

什么是循环依赖

类与类之间的依赖关系形成了闭环,就会导致循环依赖问题的产生。举例来说,假设存在两个服务类A和服务类B,如果A通过依赖注入的方式引用了B,且B通过依赖注入的方式引用了A,那么A和B之间就存在循环依赖。
推广来说,如果涉及多个类,也存在这种依赖关系,那么也是循环依赖问题。
循环依赖问题比较严重,有时会影响服务启动,有时会导致死循环调用(如果线上环境出现循环调用,会导致程序进入死循环,然后服务崩溃,进而导致用户请求无法响应,造成生产事故),应引起足够的重视。

循环依赖的处理现状

Spring 支持解决循环依赖,但是仅能支持特定的场景,对于不支持的场景,会在启动时报错。Spring 提供的能力后面会详细重点说明下,在Spring Boot 2.6.0版本开始,默认禁用对循环依赖的支持。也就是说,Spring Boot 2.6.0版本及之后版本,如果存在循环依赖,不管是何种场景,都会报启动错误。启动报错关键信息如下:

Description:The dependencies of some of the beans in the application context form a cycle:┌─────┐
|  a (field private com.github.courage007.springbootstarter.service.B com.github.courage007.springbootstarter.service.A.b)
↑     ↓
|  b (field private com.github.courage007.springbootstarter.service.A com.github.courage007.springbootstarter.service.B.a)
└─────┘Action:Relying upon circular references is discouraged and they are prohibited by default. Update your application to remove the dependency cycle between beans. As a last resort, it may be possible to break the cycle automatically by setting spring.main.allow-circular-references to true.

总结来说,Spring 支持一定程度的循环依赖的解决,但是在2.6.0版本及之后的版本,默认禁用该功能。也就是说,Spring Boot 2.6.0版本及之后版本,如果存在循环依赖,不管是何种场景,都会报启动错误。
那么Spring 都支持哪些循环依赖的场景呢,后续如果出现循环依赖问题,又该如何解决呢?接下来详细介绍这些内容。

Spring IoC简介

在正式介绍 Spring 如何解决 Bean 的循环依赖问题前,先简要介绍下Spring 如何实现Bean的注入。Spring使用IoC技术实现Bean的注入,在具体策略上采用了依赖注入的方式。在Spring中支持的依赖注入实现主要有三种:构造器注入、setter方法注入(也称属性注入)、接口注入等。相对于前两种注入方式,接口注入比繁琐和死板,被注入对象必须声明和实现另外的接口,所以常用的Bean注入方式主要有两种:构造器注入和setter方法注入。

Spring 如何解决循环依赖

根据依赖注入的方式不同,可以将循环依赖的场景进行以下划分:

依赖注入A构造器注入A属性注入
B构造器注入启动报错,Spring无法自动解决,需要手动解决启动成功,Spring可以自动解决
B属性注入启动成功,Spring可以自动解决启动成功,Spring可以自动解决

A构造器注入B,B构造器注入A

针对A构造器注入B,B构造器注入A的情况,Spring 无法解决这种循环依赖问题,启动时就会报错,报错内容如下:

***************************
APPLICATION FAILED TO START
***************************Description:The dependencies of some of the beans in the application context form a cycle:┌─────┐
|  a defined in file [/spring-boot-example/spring-boot-web-starter/target/classes/com/github/courage007/springbootwebstarter/resource/A.class]
↑     ↓
|  b defined in file [/spring-boot-example/spring-boot-web-starter/target/classes/com/github/courage007/springbootwebstarter/resource/B.class]

因为这种循环依赖在启动时就会被发现,所以不会带入到线上环境,影响可控,但错误比较低级。

A构造器注入B,B属性注入A

针对A构造器注入B,B构造器注入A的情况,Spring 可以解决这种循环依赖问题,不会影响Spring应用的启动。示例代码如下:

@Service
public class A {private B b;public A(B a) {this.b = b;}public void test() {System.out.println("A");}
}@Service
public class B {@Autowiredprivate A a;public void test() {System.out.println("B");}
}

虽然Spring可以解决这种循环依赖问题,但是却无法解决方法之间的循环调用,如果同时存在相互调用,则会导致实例不断的被初始化,从而导致栈溢出。示例代码如下:

@Service
public class A {private B b;public A(B a) {this.b = b;}public void test() {System.out.println("A");b.test();}
}@Service
public class B {@Autowiredprivate A a;public void test() {System.out.println("B");a.test();}
}

如果客户端调用了实例A的test方法或实例B的test方法,那么将会触发循环调用,进而导致服务崩溃。异常堆栈示例如下:

*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at ./open/src/java.instrument/share/native/libinstrument/JPLISAgent.c line: 872
2023-11-10 16:46:03.497 ERROR 13643 --- [nio-8082-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Handler dispatch failed; nested exception is java.lang.StackOverflowError] with root causejava.lang.StackOverflowError: nullat java.base/java.nio.ByteBuffer.position(ByteBuffer.java:1158) ~[na:na]at java.base/java.nio.ByteBuffer.position(ByteBuffer.java:263) ~[na:na]at java.base/sun.nio.cs.UTF_8.updatePositions(UTF_8.java:80) ~[na:na]at java.base/sun.nio.cs.UTF_8$Encoder.encodeArrayLoop(UTF_8.java:509) ~[na:na]at java.base/sun.nio.cs.UTF_8$Encoder.encodeLoop(UTF_8.java:564) ~[na:na]at java.base/java.nio.charset.CharsetEncoder.encode(CharsetEncoder.java:576) ~[na:na]at java.base/sun.nio.cs.StreamEncoder.implWrite(StreamEncoder.java:292) ~[na:na]at java.base/sun.nio.cs.StreamEncoder.implWrite(StreamEncoder.java:281) ~[na:na]at java.base/sun.nio.cs.StreamEncoder.write(StreamEncoder.java:125) ~[na:na]at java.base/java.io.OutputStreamWriter.write(OutputStreamWriter.java:208) ~[na:na]at java.base/java.io.BufferedWriter.flushBuffer(BufferedWriter.java:120) ~[na:na]at java.base/java.io.PrintStream.write(PrintStream.java:605) ~[na:na]at java.base/java.io.PrintStream.print(PrintStream.java:745) ~[na:na]at java.base/java.io.PrintStream.println(PrintStream.java:882) ~[na:na]at com.github.courage007.springbootwebstarter.resource.A.test(A.java:18) ~[classes/:na]at com.github.courage007.springbootwebstarter.resource.B.test(B.java:21) ~[classes/:na]at com.github.courage007.springbootwebstarter.resource.A.test(A.java:19) ~[classes/:na]at com.github.courage007.springbootwebstarter.resource.B.test(B.java:21) ~[classes/:na]

针对这种情况,因为是在运行时才会发现,如果测试用例覆盖该场景,则不会导致问题流出到现网环境,否则会导致服务崩溃,属于生产事故。

A属性注入B,B构造器注入A

针对A属性注入B,B构造器注入A的情况,其分析与A构造器注入B,B构造器注入A一致,保持相同结论即可。

A属性注入B,B属性注入A

针对A属性注入B,B属性注入A的情况,其分析与A构造器注入B,B属性注入A相似,保持相同结论即可。这里给出示例代码:

@Service
public class A {@Autowiredprivate B b;public void test() {System.out.println("A");}
}@Service
public class B {@Autowiredprivate A a;public void test() {System.out.println("B");}
}

源码分析循环依赖

接下来从Spring Bean的创建过程,看看 Spring 是如何解决一定程度的循环依赖问题。首先,定位到AbstractBeanFactory抽象类的createBean方法。这个方法是Bean创建的入口。
进入其实现,会进入到AbstractAutowireCapableBeanFactory抽象类(这里仅展示关键源码,完整代码可以执行查看源码)。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactoryimplements AutowireCapableBeanFactory {// ...@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {// ...// 优先尝试从代理中获取Bean实例Object bean = resolveBeforeInstantiation(beanName, mbdToUse);if (bean != null) {return bean;}try {Object beanInstance = doCreateBean(beanName, mbdToUse, args);if (logger.isTraceEnabled()) {logger.trace("Finished creating instance of bean '" + beanName + "'");}return beanInstance;} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {// A previously detected exception with proper bean creation context already,// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.throw ex;} catch (Throwable ex) {throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);}}protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {// 从这几行代码可知,对于多例模式,是会直接创建Bean实例,所以多例模式下,循环依赖问题无法解决BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {// 创建bean实例,主要解决构造器注入的场景instanceWrapper = createBeanInstance(beanName, mbd, args);}// 缓存的单例集合可以用来解决一定程度的循环依赖问题// 启用缓存的场景:(1) 单例场景;(2) 启用允许循环依赖的开关boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance.Object exposedObject = bean;try {// 创建bean实例,主要解决属性注入的场景populateBean(beanName, mbd, instanceWrapper);// bean的实例化exposedObject = initializeBean(beanName, exposedObject, mbd);}catch (Throwable ex) {if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);}}if (earlySingletonExposure) {Object earlySingletonReference = getSingleton(beanName, false);if (earlySingletonReference != null) {if (exposedObject == bean) {exposedObject = earlySingletonReference;}else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);for (String dependentBean : dependentBeans) {if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);}}if (!actualDependentBeans.isEmpty()) {throw new BeanCurrentlyInCreationException(beanName,"Bean with name '" + beanName + "' has been injected into other beans [" +StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +"] in its raw version as part of a circular reference, but has eventually been " +"wrapped. This means that said other beans do not use the final version of the " +"bean. This is often the result of over-eager type matching - consider using " +"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");}}}}// ...return exposedObject;}protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {Object exposedObject = bean;if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);}}return exposedObject;}
}public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {// .../** Cache of singleton objects: bean name to bean instance. */private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);/** Cache of singleton factories: bean name to ObjectFactory. */private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);/** Cache of early singleton objects: bean name to bean instance. */private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);/** Set of registered singletons, containing the bean names in registration order. */private final Set<String> registeredSingletons = new LinkedHashSet<>(256);protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(singletonFactory, "Singleton factory must not be null");synchronized (this.singletonObjects) {if (!this.singletonObjects.containsKey(beanName)) {this.singletonFactories.put(beanName, singletonFactory);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}}protected Object getSingleton(String beanName, boolean allowEarlyReference) {// Quick check for existing instance without full singleton lock// 先从一级本地缓存获取对象Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {// 如果一级缓存没有,则考虑从二级缓存获取对象singletonObject = this.earlySingletonObjects.get(beanName);// 根据是否允许启用allowEarlyReference,再次获取对象if (singletonObject == null && allowEarlyReference) {synchronized (this.singletonObjects) {// Consistent creation of early reference within full singleton locksingletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null) {// 如果二级缓存没有,则考虑从三级缓存获取对象并将其放置到二级缓存(实际从二级缓存获取对象)ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}}}return singletonObject;}// ...
}

经过上述源码分析,可知对于Bean多例(Prototype)场景,Spring 是不支持解决循环依赖的,只支持Bean单例(Singleton)的场景。而且Spring还提供了允许循环依赖的开关(默认是关闭的)。在创建Bean的时候,Spring 使用了三级缓存。Spring优先从一级缓存singletonObjects中获取对象;如果没有,则尝试从二级缓存earlySingletonObjects中获取;如果还是没有,就从三级缓存singletonFactory获取对象,然后将对象放置到二级缓存,并从三级缓存溢出该对象。这里只是Spring Bean对象创建的过程,那么Spring 是如何解决Bean的循环依赖的问题呢?
其实,这里的关键是Spring引入了earlyBeanReference(早期Bean的引用),也就是说在创建Bean的时候,会注入一个还没初始化的对象,从而解决了循环依赖重复创建的问题。这里以A属性注入B,B属性注入A为例,介绍Spring是如何支持循环依赖的。首先在创建A的实例时,会先创建A的对象引用,然后再去查找A依赖的对象,如果不存在,则需要进入依赖对象的创建过程,同样地,会先创建对象的引用,这里是对象B的引用。这样在A中就可以使用B,而B也是类似的操作。
如果仅使用一级缓存和二级缓存就可以解决循环依赖问题,为什么没有这么做呢?这是因为,并不是需要对所有对象都创建二级缓存,这样可以减少不必要的对象创建,从而节省内存。而引入三级缓存后,如果存在允许循环引用的场景,则会基于对象引用工厂创建对象的引用,然后将其存储到二级缓存。可以说,三级缓存的目的就是为了构造二级缓存中的元素,从而达到节省内存的效果。

循环依赖的处理

了解了Spring 支持的循环依赖的解决能力,接下来针对存在循环依赖的场景,给出合适的处理方案。
如果需要Spring Boot版本从低于2.6.0的版本升级到高于2.6.0的版本,如果现有代码存在循环依赖,且无法再短时间内消减掉该问题,则可以先在配置文件中补充下述配置,做临时规避处理:

spring:main:allow-circular-references:true  #允许循环依赖

当然,不建议在新写的代码中引入循环依赖问题。接下来根据是否存在方法循环调用,对问题进一步的划分:不存在循环调用的循环依赖,存在循环调用的循环依赖。
注意,这里不再关注循环调用的方式,统一使用A属性注入B,B属性注入A这种方式进行说明。

不存在循环调用的循环依赖

如果存在循环依赖,但是不存在循环调用,如果是在2.6.0以下版本,不会有问题,只是有引入循环调用的风险;如果是在2.6.0以上的版本,如果不主动开启允许循环依赖的特性开关,是会在启动的时候报循环依赖的错误的。但是如果开启允许循环依赖的特性开关,则不会影响启动,只是有引入循环调用的风险。
为消减掉循环调用的风险,应尝试解决掉这种循环依赖,这里给出示例代码:

// 修改前
@Service
public class A {@Autowiredprivate B b;public void test() {System.out.println("A");b.test();}
}@Service
public class B {@Autowiredprivate A a;public void test() {System.out.println("B");}
}
// 修改后// 修改前
@Service
public class A {@Autowiredprivate C c;public void test() {System.out.println("A");c.test();}
}@Service
public class B {@Autowiredprivate A a;
}@Service
public class C {public void test() {System.out.println("B");}
}

可见,这里解决掉循环依赖的方式,就是将被依赖的类中的方法,独立包装成一个类,然后被引用。当然,实际的情况可能更复杂,但是核心的处理策略都是一样的。

存在循环调用的循环依赖

如果存在循环依赖,且存在循环调用,不管是哪一个Spring 版本,都会因循环调用,导致对象重复创建,进而导致堆栈溢出,引发程序崩溃。从直接现象来看,这是开发人员因逻辑思考有问题,写入了死循环的代码导致。且该代码并没有做自测,如果没有测试用例看护,那么这种问题流出到现网环境,将会带来生产事故。
为解决这类Bug,就是要思考现有实现,看看代码逻辑,正常来说,可以先将循环调用消减掉,然后再想办法(参考上一节)消减掉循环调用。这里给出存在循环调用的循环依赖的示例代码(之前已有介绍,这里重复一下,方便阅读):

@Service
public class A {private B b;public A(B a) {this.b = b;}public void test() {System.out.println("A");b.test();}
}@Service
public class B {@Autowiredprivate A a;public void test() {System.out.println("B");a.test();}
}

总结

针对Spring Bean的循环依赖问题,如果情况允许,尽量不使用临时规避的手段容忍循环依赖问题。如果因存量代码的问题,尽量将消除循环依赖作为高优先级历史债务进行解决。循环依赖的引入,要么会影响应用的启动,要么会因方法循环调用陷入死循环,从而导致堆栈溢出,给用户带来影响。

参考

https://blog.csdn.net/wangxuelei036/article/details/104960558 spring 循环依赖以及解决方案
https://www.cnblogs.com/daimzh/p/13256413.html 讲一讲Spring中的循环依赖
https://blog.csdn.net/qq_51076413/article/details/131061348 SpringBoot3.x循环依赖
https://juejin.cn/post/7032910060044943373 Spring Boot 2.6.0正式发布:默认禁止循环依赖、增强Docker镜像构建
https://blog.csdn.net/Microhoo_/article/details/132188824 解决Spring Boot 2.6及之后版本取消了循环依赖的支持的问题
https://zhuanlan.zhihu.com/p/647315070 spring bean 三级缓存

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/139368.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

IDEA 关闭SpringBoot启动Logo/图标

一、环境 1、SpringBoot 2.6.4 Maven POM格式 <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.6.4</version><relativePath/></parent> 2、IDE…

Linux arm64异常简介和系统调用过程

文章目录 一、异常简介1.1 Exception levels1.2 异常类型 二、系统调用简介2.1 SVC指令2.2 VBAR2.3 系统调用保存现场2.4 系统调用返回 三、Linux 内核分析参考资料 一、异常简介 在ARM64体系架构中&#xff0c;异常是处理器在执行指令时可能遇到的不寻常情况或事件。这些异常…

链表经典OJ题(链表回文结构,链表带环,链表的深拷贝)

目录 前言 1.反转一个单链表。 2. 给定一个带有头结点 head 的非空单链表&#xff0c;返回链表的中间结点。 3.链表的回文结构。 4.链表带环问题&#xff08;*****&#xff09; 4.1是否带环 4.2 入环的节点 5.随机链表的复制&#xff08;链表的深拷贝&#xff09; 前言…

Redis的三种特殊数据类型

文章目录 一、Redis geospatial 地理位置二、Redis Hyperloglog 基数统计的算法三、Redis Bitmaps 位存储&#xff08;0、1&#xff09;总结 一、Redis geospatial 地理位置 1.geoadd&#xff1a;将指定的地理空间位置&#xff08;纬度、经度、名称&#xff09;添加到指定的ke…

人工智能-卷积神经网络(LeNet)

为了能够应用softmax回归和多层感知机&#xff0c;我们首先将每个大小为\(28\times28\)的图像展平为一个784维的固定长度的一维向量&#xff0c;然后用全连接层对其进行处理。 而现在&#xff0c;我们已经掌握了卷积层的处理方法&#xff0c;我们可以在图像中保留空间结构。 同…

Dubbo从入门到上天系列第五篇:Dubbo3与JDK17不兼容问题展示

文章目录 一&#xff1a;JDK 与 Dubbo版本对应问题说明 1&#xff1a;问题1 2&#xff1a;问题2 二&#xff1a;Spring与JDK版本对应关系 1&#xff1a;对应关系详图 2&#xff1a;JDK与Major对应关系图 大神链接&#xff1a;作者有幸结识技术大神孙哥为好友&#xff0c…

[ Linux Busybox ] nandwrite 命令解析

文章目录 相关结构体nandwrite 函数实现nandwrite 实现流程图 文件路径&#xff1a;busybox-1.20.2/miscutils/nandwrite.c 相关结构体 MTD 相关信息结构体 struct mtd_info_user {__u8 type; // MTD 设备类型__u32 flags; // MTD设备属性标志__u32…

基于STM32控制直流电机加减速正反转仿真设计

**单片机设计介绍&#xff0c;基于STM32控制直流电机加减速正反转仿真设计 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图 五、 程序六、 文章目录 一 概要 本设计由STM32F103、L298N电机驱动电路、按键电路组成。通过按键可以控制电机&#xff0c;正转、反转、加…

商越科技:渗透测试保障平台安全,推动线上采购高效运转

商越科技是数字化采购解决方案提供商&#xff0c;在同赛道企业中始终保持前列。商越科技通过自主研发的智能采购中台、SaaS应用及运营服务等为企业搭建专属的互联网采购平台&#xff0c;帮助企业实现采购数字化以及智能化转型&#xff0c;提高工作效率、降低采购成本。 打造数字…

Linux基础开发工具之调试器gdb

文章目录 1.编译成的可调试的debug版本1.1gcc test.c -o testdebug -g1.2readelf -S testdebug | grep -i debug 2.调试指令2.0quit退出2.1list/l/l 数字: 显示代码2.2run/r运行2.3断点相关1. break num/b num: 设置2. info b: 查看3. d index: 删除4. n: F10逐过程5. p 变量名…

Java必刷入门递归题×5(内附详细递归解析图)

目录 1.求N的阶乘 2.求12...N的和 3.顺序打印数字的每一位 4.求数字的每一位之和 5.求斐波拉契数列 1.求N的阶乘 &#xff08;1&#xff09;解析题目意思 比如求5的阶乘&#xff0c;符号表示就是5&#xff01;&#xff1b;所以5&#xff01;5*4*3*2*1我们下面使用简单的…

SSM图书管理系统开发mysql数据库web结构java编程计算机网页源码eclipse项目

一、源码特点 SSM 图书管理系统是一套完善的信息系统&#xff0c;结合springboot框架和bootstrap完成本系统&#xff0c;对理解JSP java编程开发语言有帮助系统采用SSM框架&#xff08;MVC模式开发&#xff09;&#xff0c;系统具有完整的源代码和 数据库&#xff0c;系统主要…

Linux-Docker的基础命令和部署code-server

1.安装docker 1.安装需要的安装包 yum install -y yum-utils2.设置镜像仓库 yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo3.安装docker yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin do…

多彩的树 -----题解(状压dp + 容斥原理)

目录 多彩的树 题目描述 输入描述: 输出描述: 输入 输出 思路解析&#xff1a; 代码实现&#xff1a; 多彩的树 时间限制&#xff1a;C/C 5秒&#xff0c;其他语言10秒 空间限制&#xff1a;C/C 262144K&#xff0c;其他语言524288K 64bit IO Format: %lld 题目描述 …

【Springboot】Vue3-Springboot引入JWT实现登录校验以及常见的错误解决方案

文章目录 前言一、JWT简单介绍二、token校验设计思路三、使用步骤Springboot部署JWT引入依赖&#xff1a;创建登录实体类后端&#xff1a;LoginController.java路由守卫函数 四、问题 前言 项目版本&#xff1a; 后端&#xff1a; Springboot 2.7、 Mybatis-plus、Maven 3.8.1…

Python与ArcGIS系列(六)查找和修复数据源

目录 0 简述1 查找丢失数据源2 findAndReplaceWorkspacePaths()方法修复丢失数据源3 replaceWorkspaces()方法修复丢失数据源4 replaceDataSource()修复单个图层和表对象0 简述 当对数据源进行移动、转换和删除时都会导致数据源丢失链接问题,无法正常显示地图数据。对于多个数…

C/C++轻量级并发TCP服务器框架Zinx-游戏服务器开发004:游戏核心消息处理 - 玩家类的实现

文章目录 0 代码仓库1 需求2 AOI设计2.1 AOI算法简介2.2 AOI数据结构及实现2.2.1 玩家2.2.2 网格对象2.2.3 游戏世界矩形2.2.4 获取周围玩家的实现2.2.5 代码测试 2.3 GameRole结合AOI创建玩家2.3.1 创建游戏世界全局对象-GameRole继承AOIWorld的Player2.3.2 把玩家到游戏世界的…

IDEA插件开发--持久化配置信息方案

这里写自定义目录标题 配置信息持久化存储保存配置文件的方式每种方式的实现方案1.PropertiesComponent&#xff1a;2.PersistentStateComponent&#xff1a;3.Project Settings&#xff1a;4.外部文件&#xff1a; 5.数据库&#xff1a;6.加密数据&#xff1a;7,自定义配置文件…

Docker 安装 MySQL 8

Docker 安装 MySQL 8 本文实现在docker中安装MySQL 8&#xff0c;含文件映射、密码、mysql参数设置等 一、拉取镜像 其他版本可以换为你需要的版本号 docker pull mysql:8.0.20二、运行容器 注意&#xff1a;第一个-v的第一个路径是宿主机的数据存储位置第二个-v的第一个路…

1.docker linux离线环境安装 20.1.0.12

目录 概述下载解压docker 卸载docker 安装检查安装环境常用命令结束 概述 docker离线环境安装 20.1.0.12 , centos 7.x 下载 安装包下载 解压 [roothadoop01 soft]# unzip docker_20_1_0_12.zip [roothadoop01 soft]# cd docker_20_1_0_12 [roothadoop01 docker_20_1_0_1…