设计模式——Spring注解编程模型

最新推荐文章于 2021-09-23 23:51:46 发布
最新推荐文章于 2021-09-23 23:51:46 发布
阅读量979 收藏 10
点赞数 1
分类专栏： Spring 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39385118/article/details/100013973
版权

文章目录

1. 引言

模式注解使框架的配置变得简洁明了，从Spring Framework 3.1开始Spring开始全面支持面向注解配置，其中一些核心注解如下

Spring模式注解：

Spring 注解场景说明起始版本
@Repository数据仓库模式注解2.0
@Component通用组件模式注解2.5
@Service服务模式注解2.5
@ControllerWeb控制器模式注解2.5
@Configuration配置类模式注解3.0

装配注解：

Spring 注解场景说明起始版本
@ImportResource替换XML元素2.5
@Import导入bean或者@configuration配置类3.0
@ComponentScan扫描指定package下标注Spring模式注解的类3.1

依赖注入注解如下表所示：

Spring 注解场景说明起始版本
@AutowiredBean依赖注入，支持多种依赖查找方式2.5
@Qualifier细粒度限定@autowired注入2.5
Spring 注解场景说明起始版本
@Resource@Bean依赖注入，仅支持名称依赖查找方式2.5

Bean定义注解如下表所示

Spring 注解场景说明起始版本
@Bean替换XML元素3.0
@DependsOn替换XML元素3.0
@Lazy替换XML元素3.0
@Primary替换XML元素3.0
@Role替换XML元素3.1
@Lookup替换XML元素4.1

Spring条件装配注解：

Spring 注解场景说明起始版本
@Profile配置化条件装配3.1
@Conditional编程条件装配4.0

配置属性注解：

Spring 注解场景说明起始版本
@PropertySource配置属性抽象3.1
@PropertySources@PropertySource集合注解4.0

生命周期回调注解

Java 注解场景说明起始版本
@PostConstruct替换XML元素2.5
@PreDestroy替换XML元素2.5

可以标注注解的属性

Java 注解场景说明起始版本
@AliasFor别名注解属性，实现复用的目的4.2

性能注解：

Java 注解场景说明起始版本
@Indexed提升Spring模式注解的扫描效率5.0

2. Spring注解编程模型

主要有四个方面分别是：

  • 元注解(Meta-Annotations)
  • Spring模式注解(Stereotype Annotations)
  • Spring组合注解(Composed Annotations)
  • Spring注解属性别名和覆盖(Attribute Aliases and Overrides)

2.1 元注解(Meta-Annotations)

元注解指一个能声明在其他注解上的注解，如果一个注解标注在其他注解上，那么他就是元注解。根据Java语言规范，注解之间不存在继承关系，因此可以通过元注解来注解到另一个注解达到“派生”的作用，这种“派生”特性需要确保注解之间的属性方法签名完全一致.

2.2 Spring模式注解（Stereotype Annotations）

引用Spring重的Wiki描述里的一句话

A sterotype annotation is an annotation that is used to declare the role that a componnet plays within the application.

简而言之Stereotype Annotations就是说明组件扮演的角色，以@Component注解为例，@Service、@Repository、@Controler、@RestController及@Configuration都包含@Component注解，所以包含@Component的功能，同时他们在不同的场景下扮演不同的角色。在Spring Framework 4.x 之前以@Component注解为例，只能识别两层的@Component派生注解，在Spring Framework 4.x 之后可以递归识别多层次的@Component派生注解。
扫描注解并模拟初始化过程简单的原理我在另一篇Java基础 注解中有简要的分析了一下，主要过程就是根据配置的basePackage属性到该路径下搜索有相应注解标记的类。
需要另外注意的是Spring在扫描的过程中还会有excludeFilters和includeFilters，排除excludeFilters中的注解，属于includeFilters中的注解将会通过筛选条件（默认初始化时includeFilters会加入@Component）。
还有一点是，处于性能方面的Spring获取底层元数据的方式是通过ASM实现的，而不是通过反射，如ClassReader类，相对于ClassLoader体系，Spring ASM更为底层，读取的是类资源，直接操作的是其中的字节码，获取相关元信息，在读取元信息方面Spring抽象出MetadataReader接口。

2.3 Spring组合注解（Composed Annotations）

其目的在于将多个注解行为组合成单个自定义注解，比如@SpringBootApplication注解由@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan等几个注解组成，Spring并没有考虑通过Java反射的手段来解析元注解信息，而是抽象出AnnotationMetadata接口，其实现类为AnnotationMetadataReadingVisitor，从Spring 4.0开始，在初始化过程中AnnotationMetadataReadingVisitor所关联的AnnotationAttributesReadingVisitor采用递归查找元注解，并保存在AnnotationMetadataReadingVisitor的metaAnnotationMap字段中。
其中核心代码如下：

package org.springframework.core.type.classreading;

/**
 * ASM visitor which looks for annotations defined on a class or method,
 * including meta-annotations.
 *
 * <p>This visitor is fully recursive, taking into account any nested
 * annotations or nested annotation arrays.
 *
 * @author Juergen Hoeller
 * @author Chris Beams
 * @author Phillip Webb
 * @author Sam Brannen
 * @since 3.0
 */
final class AnnotationAttributesReadingVisitor extends RecursiveAnnotationAttributesVisitor {

	private final MultiValueMap<String, AnnotationAttributes> attributesMap;

	private final Map<String, Set<String>> metaAnnotationMap;


	public AnnotationAttributesReadingVisitor(String annotationType,
			MultiValueMap<String, AnnotationAttributes> attributesMap, Map<String, Set<String>> metaAnnotationMap,
			@Nullable ClassLoader classLoader) {

		super(annotationType, new AnnotationAttributes(annotationType, classLoader), classLoader);
		this.attributesMap = attributesMap;
		this.metaAnnotationMap = metaAnnotationMap;
	}


	@Override
	public void visitEnd() {
		super.visitEnd();

		Class<? extends Annotation> annotationClass = this.attributes.annotationType();
		if (annotationClass != null) {
			List<AnnotationAttributes> attributeList = this.attributesMap.get(this.annotationType);
			if (attributeList == null) {
				this.attributesMap.add(this.annotationType, this.attributes);
			}
			else {
				attributeList.add(0, this.attributes);
			}
			if (!AnnotationUtils.isInJavaLangAnnotationPackage(annotationClass.getName())) {
				try {
					Annotation[] metaAnnotations = annotationClass.getAnnotations();
					if (!ObjectUtils.isEmpty(metaAnnotations)) {
						Set<Annotation> visited = new LinkedHashSet<>();
						for (Annotation metaAnnotation : metaAnnotations) {
              //递归查找元注解
							recursivelyCollectMetaAnnotations(visited, metaAnnotation);
						}
						if (!visited.isEmpty()) {
							Set<String> metaAnnotationTypeNames = new LinkedHashSet<>(visited.size());
							for (Annotation ann : visited) {
								metaAnnotationTypeNames.add(ann.annotationType().getName());
							}
							this.metaAnnotationMap.put(annotationClass.getName(), metaAnnotationTypeNames);
						}
					}
				}
				catch (Throwable ex) {
					if (logger.isDebugEnabled()) {
						logger.debug("Failed to introspect meta-annotations on " + annotationClass + ": " + ex);
					}
				}
			}
		}
	}

  //递归查找元注解
	private void recursivelyCollectMetaAnnotations(Set<Annotation> visited, Annotation annotation) {
		Class<? extends Annotation> annotationType = annotation.annotationType();
		String annotationName = annotationType.getName();
		if (!AnnotationUtils.isInJavaLangAnnotationPackage(annotationName) && visited.add(annotation)) {
			try {
				// Only do attribute scanning for public annotations; we'd run into
				// IllegalAccessExceptions otherwise, and we don't want to mess with
				// accessibility in a SecurityManager environment.
				if (Modifier.isPublic(annotationType.getModifiers())) {
					this.attributesMap.add(annotationName,
							AnnotationUtils.getAnnotationAttributes(annotation, false, true));
				}
				for (Annotation metaMetaAnnotation : annotationType.getAnnotations()) {
					recursivelyCollectMetaAnnotations(visited, metaMetaAnnotation);
				}
			}
			catch (Throwable ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to introspect meta-annotations on " + annotation + ": " + ex);
				}
			}
		}
	}

}

2.3.1 MetadataReader

在读取元信息方面，Spring抽象出MetadataReader接口：

package org.springframework.core.type.classreading;

/**
 * Simple facade for accessing class metadata,
 * as read by an ASM {@link org.springframework.asm.ClassReader}.
 *
 * @author Juergen Hoeller
 * @since 2.5
 */
public interface MetadataReader {

	/**
	 * Return the resource reference for the class file.
	 */
	Resource getResource();

	/**
	 * Read basic class metadata for the underlying class.
	 */
	ClassMetadata getClassMetadata();

	/**
	 * Read full annotation metadata for the underlying class,
	 * including metadata for annotated methods.
	 */
	AnnotationMetadata getAnnotationMetadata();

}

需要注意的是无论是ClassMetadata还是AnnotationMetadata，均没有Java Class和Annotation API那样丰富的关联属性，MetadataReader有明显的资源特性，getResource()方法关联了类资源的Resource信息，他在Spring Framework中有一个final实现类SimpleMetadataReader，其关联的ClassMetadata和AnnotationMetadata信息在构造阶段完成初始化

package org.springframework.core.type.classreading;

/**
 * {@link MetadataReader} implementation based on an ASM
 * {@link org.springframework.asm.ClassReader}.
 *
 * <p>Package-visible in order to allow for repackaging the ASM library
 * without effect on users of the {@code core.type} package.
 *
 * @author Juergen Hoeller
 * @author Costin Leau
 * @since 2.5
 */
final class SimpleMetadataReader implements MetadataReader {

	private final Resource resource;

	private final ClassMetadata classMetadata;

	private final AnnotationMetadata annotationMetadata;


	SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException {
		InputStream is = new BufferedInputStream(resource.getInputStream());
		ClassReader classReader;
		try {
			classReader = new ClassReader(is);
		}
		catch (IllegalArgumentException ex) {
			throw new NestedIOException("ASM ClassReader failed to parse class file - " +
					"probably due to a new Java class file version that isn't supported yet: " + resource, ex);
		}
		finally {
			is.close();
		}

		AnnotationMetadataReadingVisitor visitor = new AnnotationMetadataReadingVisitor(classLoader);
		classReader.accept(visitor, ClassReader.SKIP_DEBUG);

		this.annotationMetadata = visitor;
		// (since AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisitor)
		this.classMetadata = visitor;
		this.resource = resource;
	}


	@Override
	public Resource getResource() {
		return this.resource;
	}

	@Override
	public ClassMetadata getClassMetadata() {
		return this.classMetadata;
	}

	@Override
	public AnnotationMetadata getAnnotationMetadata() {
		return this.annotationMetadata;
	}

}

AnnotationMetadataReadingVisitor同时实现了ClassMetadata和AnnotationMetadata接口，在ClassPathScanningCandidateComponentProvider#findCandidateComponents(String)方法中MetadataReader实例由由metadataReaderFactory.getMetadateReader实例生成。

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				if (resource.isReadable()) {
					try {
            //默认是CachingMetadataReaderFactory
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						if (isCandidateComponent(metadataReader)) {
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setResource(resource);
							sbd.setSource(resource);
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
								candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}
						else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					}
					catch (Throwable ex) {
						...
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		}
		catch (IOException ex) {
		  ...
		}
		return candidates;
	}

这里的getMetadataReaderFactory()默认是CachingMetadataReaderFactory，他提供getMetadataReader两种重载方法

public interface MetadataReaderFactory {

	/**
	 * Obtain a MetadataReader for the given class name.
	 * @param className the class name (to be resolved to a ".class" file)
	 * @return a holder for the ClassReader instance (never {@code null})
	 * @throws IOException in case of I/O failure
	 */
	MetadataReader getMetadataReader(String className) throws IOException;

	/**
	 * Obtain a MetadataReader for the given resource.
	 * @param resource the resource (pointing to a ".class" file)
	 * @return a holder for the ClassReader instance (never {@code null})
	 * @throws IOException in case of I/O failure
	 */
	MetadataReader getMetadataReader(Resource resource) throws IOException;

}

下面我们通过一个简单的栗子来通过MetadataReader获取一下元注解

/**
 * 通过MetadataReaderFactory获取metadataReader实例并获取元信息
 */
@RestController
public class AnnotationMetadataInfo {

  public static void main(String[] args) throws IOException {
    String className = AnnotationMetadataInfo.class.getName();
    MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory();
    //通过class全限定名称获取MetadataReader实例
    MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
    //获取当前类的注解元信息
    AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
    //获取当前类的注解元信息的全限定名
    Set<String> set = annotationMetadata.getAnnotationTypes();
    System.out.println(set);
    set.forEach(annotationTypeName -> {
      //通过注解全限定名找到其所有的元注解
      annotationMetadata.getMetaAnnotationTypes(annotationTypeName).forEach(
          metaAnnotationTypeName -> {
            System.out.println(metaAnnotationTypeName);
          }
      );
    });
  }
}

2.4 Spring注解属性别名和覆盖(Attribute Aliases and Overrides)

little-motor
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
别再用if-else了，用注解去代替他吧，你会发现新大陆！
Java圈全能架构师的博客
06-18 1073
经常在网上看到一些名为“别再if-else走天下了”，“教你干掉if-else”等之类的文章，大部分都会讲到用策略模式去代替if-else。策略模式实现的方式也大同小异。主要是定义统一行为（接口或抽象类），并实现不同策略下的处理逻辑（对应实现类）。客户端使用时自己选择相应的处理类，利用工厂或其他方式。 注解实现 本文要说的是用注解实现策略模式的方式，以及一些注意点。 话不多说，还是以最常 见的订单处理为例。首先定义这样一个订单实体类： @Data publicclassOrder{ /...
JAVA注解与设计模式
冰丶heart
04-09 540
JAVA注解 1.内置注解 2.自定义注解 什么是注解？ Jdk1.5新增新技术，注解。很多框架为了简化代码，都会提供有些注解。可以理解为插件，是代码级别的插件，在类的方法上写：@XXX，就是在代码上插入了一个插件。 注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。 注解分类：内置注解(也成为元注解 jdk 自带注解)、自定义注解（Spring框架） 什么是内置注解 比如 （1） @Sup...
自定义注解与设计模式
qq_42207047的博客
10-08 207
自定义注解与设计模式 一. 自定义注解 1.1什么是注解？ Jdk1.5新增新技术，注解。很多框架为了简化代码，都会提供有些注解。可以理解为插件，是代码级别的插件，在类的方法上写：@XXX，就是在代码上插入了一个插件。 注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。 注解分类：内置注解(也称为元注解，jdk 自带注解)、自定义注解（Spring框架） 1.2 什么是内置注解 比如 （1）...
Spring之自定义注解与设计模式
StayKib的博客
05-27 383
一、目标 熟悉注解底层原理 完成ORM框架底层原理 常用设计模式 单例、工厂、代理 二、自定义注解 1.1 什么是注解 Jdk1.5新增新技术，注解。很多框架为了简化代码，都会提供有些注解。可以理解为插件，是代码级别的插件，在类的方法上写：@XXX，就是在代码上插入了一个插件。 注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。 注解分类：内置注解(也成为元注解 jdk 自带注解)、自定义注解（Spring框架） 1.2 什么是内置注解 jdk自带的注解 比如： @SuppressWarning
Spring中涉及的设计模式总结
热门推荐
iCoding91
04-22 5万+
Spring中涉及的设计模式总结 1.简单工厂(非23种设计模式中的一种) 实现方式：BeanFactory。 Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。 实质：由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。 实现原理： bean容器的启...
SSM框架——Spring+SpringMVC+Mybatis的搭建教程源码
11-12
它采用模型-视图-控制器（Model-View-Controller，MVC）设计模式，将应用程序的业务逻辑、数据和用户界面分离，提高了代码的可维护性和可测试性。在SpringMVC中，DispatcherServlet作为核心组件，负责接收请求并分发...
毕业设计——基于SSM的个人书签管理系统.zip
最新发布
12-30
在个人书签管理系统中，Spring MVC会处理用户的交互，如添加、删除和查找书签，通过模型-视图-控制器（Model-View-Controller，MVC）的设计模式将这些操作与显示和数据处理分离。 3. **MyBatis**：MyBatis是一个...
SpringMVC学习(四)——Spring、MyBatis和SpringMVC的整合
05-15
它采用模型-视图-控制器（MVC）架构模式，将业务逻辑、数据展示和用户交互分离，使得代码结构清晰，便于分工协作。 整合Spring、MyBatis和SpringMVC的步骤大致如下： 1. **环境准备**：确保已安装Java开发环境，并...
毕业设计Java——学生宿舍管理系统.zip
09-27
【标题】中的“毕业设计Java——学生宿舍管理系统”表明这是一个基于Java编程语言开发的学生宿舍管理系统的毕业设计项目。在这样的系统中，通常会涉及到数据库管理、用户界面设计、权限控制等多个方面，旨在提高学校...
毕业设计基于SSM的图书馆管理系统
04-12
6. **系统实现**：在实际开发中，系统可能采用MVC设计模式，其中Controller层负责接收请求，调用Service层进行业务逻辑处理，Service层再调用DAO层与数据库进行交互。MyBatis的XML配置文件定义了SQL语句和映射规则，...
设计模式
y_index的博客
09-10 136
什么是设计模式？ 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。 设计模式的分类？ 总体来说设计模式分为三大类： 创建型模式，共五...
day17复习-设计模式,注解,反射入门
FXA9408的博客
09-23 128
1.设计模式 1.1概念 什么是设计模式? 设计模式一种编程思想,一种编程思路.也就是套路.是经过大量实践检验的比较好编程思路. Java中的设计模式分为23种 主要分3大类 1.创建型设计模式 2.结构型设计模式 3.行为型设计模式 1.2单例设计模式 什么是单例设计模式? 简单的说,通过这种套路设计的程序只会有一个对象.所以该种设计模式最重要的点就是设计完成后,保证对象的唯一 优点:节约内存,方便管理 缺点: 1.3Java中单例设计模式的步骤 1.私有化构造方法,防止外界调用构造方法创建对象 2.创建
基于Spring注解实现的工厂模式
Daniel的专栏
05-14 9644
本文转自oschina南寒之星的博文，原文链接如下：https://my.oschina.net/u/923324/blog/832269 摘要: 工厂模式是大家熟知的一种设计模式，在spring BeanFactory将这模式运用自如。 前面讲过如果通过xml配置的方式实现，今天我们来讲讲如何通过注解的方式实现工厂模式。 主要思路 1. 扫描classPath下的的类，将这些class存储
深入解析spring中用到的九种设计模式
weixin_30740295的博客
06-01 7715
转载请注明出处，文章首发于：http://itxxz.com/a/javashili/tuozhan/2014/0601/7.html 设计模式作为工作学习中的枕边书，却时常处于勤说不用的尴尬境地，也不是我们时常忘记，只是一直没有记忆。 今天，螃蟹在IT学习者网站就设计模式的内在价值做一番探讨，并以spring为例进行讲解，只有领略了其设计的思想理念，才能在工作学习中运用到“无形”...
跟Evan学Sprign编程思想 | Spring注解编程模式【译】
Eshare分享
08-21 659
Spring注解编程模式 概况 多年来，Spring Framework不断发展对注解、元注解和组合注解的支持。 本文档旨在帮助开发人员（Spring的最终用户以及Spring Framework和Spring组合项目的开发人员）开发和使用Spring注解。 本文档的目标 本文档的主要目标包括以下内容的解释： - 如何使用Spring注解。 - 如何开发用于Spring...
使用Spring的注解方式实现AOP的细节
李阿昀的博客
10-21 1万+
前面我们已经入门使用Spring的注解方式实现AOP了，现在我们再来学习使用Spring的注解方式实现AOP的一些细节。本文是建立在使用Spring的注解方式实现AOP入门的案例的基础之上的。 本文是来讲解使用Spring的注解方式实现AOP的一些细节，其实说白了就是学习如何使用各种通知而已，例如前置通知、后置通知、异常通知、最终通知、环绕通知等，之前我们已经学习了前置通知，现在就来学习剩余的通知
Spring中的设计模式
我的博客
03-21 2392
工厂模式 Spring IOC就是通过工厂模式来实现的，将对象的创建和管理过程交由Spring去完成，主要通过springFactory来实现，根据传入bean的名字来获取对象。 当spring启动时会先通过注解或xml配置获取bean的beanDefinition信息，然后将其放在springFactory的beanDefinitionMap中，key为bean的名字； 在这个地方Spring为为我们提供了一个切入点可以用来修改beanDefinition，可以通过实现接口BeanFactoryPost
Spring错误——Spring 注解——factory-bean reference points back to the same bean definition
05-23
这个错误通常是由于循环依赖引起的。循环依赖是指两个或多个Bean相互依赖，其中一个Bean依赖于另一个Bean的实例，而另一个Bean依赖于第一个Bean的实例。 在Spring中，循环依赖可以通过使用构造函数注入或者使用@Lazy注解来解决。但是，有时候我们会遇到一些复杂的情况，需要使用工厂方法创建Bean。这时，如果我们在Bean定义中使用了factory-bean属性以及ref属性指向同一个Bean定义，就会出现上述错误。 要解决这个问题，可以尝试以下两种方法： 1.使用@DependsOn注解：在Bean定义中使用@DependsOn注解来指定Bean之间的依赖关系。例如： ``` @Bean(name = "beanA") @DependsOn("beanB") public BeanA beanA() { return new BeanA(); } @Bean(name = "beanB") public BeanB beanB() { return new BeanB(); } ``` 2.使用ObjectFactory或Provider：将工厂Bean的返回类型设置为ObjectFactory或Provider。例如： ``` @Configuration public class AppConfig { @Bean(name = "beanA") public BeanA beanA(ObjectFactory<BeanB> beanBFactory) { BeanB beanB = beanBFactory.getObject(); return new BeanA(beanB); } @Bean(name = "beanB") public BeanB beanB() { return new BeanB(); } } ``` 以上两种方法都可以避免工厂Bean和目标Bean之间的循环依赖问题。如果你仍然遇到问题，请检查你的代码是否存在其他循环依赖。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值