Spring自动装配实现原理

最新推荐文章于 2024-07-25 11:59:12 发布
最新推荐文章于 2024-07-25 11:59:12 发布
阅读量842 收藏 1
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61532016/article/details/133891130
版权

Spring自动装配实现原理

Java中使用注解的情况主要在SpringMVC（SpringBoot等），注解实际上相当于一种标记语言，它允许你在运动时动态地对拥有标签的成员进行操作。

注意：spring框架默认不支持自动装配，要想使用自动装配需要更改spring配置文件中标签的autowire属性

自动配置有六个值可以选，分别代表不同含义：

byName

从spring环境中获取环境对象时，目标对象中的属性会根据名称在整个Spring环境中查找标签的id属性值。如果有相同的，那么获取这个对象，实现关联。

整个Spring环境：表示所有的Spring配置文件中查找，那么id不能有重复的

byType

从Spring环境中获取目标对象时，目标对象的属性会根据类型在spring环境中查找标签的class属性值。如果有相同的，获取这个对象，实现关联

缺点：如果存在多个相同类型的bean对象，会出错；如果属性为单一类型的数据，那么查找到多个关联对象会发生错误；如果属性为数组或者集合（泛型）类型，那么查找到多个关联对象不会发生异常。

constructor -> 使用构造方法完成对象注入，其实也是根据构造参数类型进行对象查找，相当于使用byType的方式

autodetect -> 自动选择：如果对象没有无参数的构造方法，那么自动选择constructor的自动装配方法进行构造注入。如果对象含有无参数的构造方法，那么自动选择byType的自动装配方式进行setter注入

no -> 不支持自动装配

default -> 表示默认采用上一级标签的自动装配的取值。如果存在多个配置文件的话，那么每一个配置文件的自动装配方式都是独立的

SpringBoot声明周期流程图

bean自身方法的声明周期

分为四步：

//执行此段代码，spring容器的bean执行实例化、属性赋值、初始化
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    
//关闭容器，执行销毁
classPathXmlApplicationContext.close();

  1. 实例化

    • 读取Spring配置文件

    • 通过反射进行bean的实例化（通过BeanFactory实例化）

  2. 属性赋值

    • 解析自动装配（byName、byType、constructor、default）DI的体现

    • 循环依赖

  3. 初始化

    • 调用XXXAware回调方法

    • 调用初始化声明周期回调（三种）

    • 如果bean实现aop创建动态代理

  4. 销毁

    • 在Spring容器关闭时进行调用

    • 调用初始化生命周期回调

下图展示了bean装载到spring应用上下文的一个典型的声明周期过程

image-20231017162656249

image-20231017162733246

@Autowired注解的自动装配过程

结论：

@Autowired是在bean属性赋值的阶段进行装配，通过bean的后置处理器进行解析

  1. 在创建一个spring上下文的时候在构造函数中 注册AutowireAnnotationBeanPostProcessor

  2. 在Bean的创建的过程中进行创建

    1. 在实例化后预解析（解析@Autowired标注的属性、方法，比如：把属性的类型、名称、属性所在的类..元数据缓存）

    2. 在属性赋值阶段真正的注入（拿着上一步的缓存的元数据去ioc容器进行查找，并且返回注入）

      1. 首先根据解析的元数据拿到类型去容器中查找

        • 如果查找结果刚好为一个，就将该bean装配给@Autowired指定的数据；

        • 如果查询的结果不止一个，那么@Autowired会根据名称来查找

        • 如果上述查找为空，那么就会抛出异常

大致流程图为下：

image-20231017164421380

@Autowired字段注入源码分析

/* ......源码注解过多，只贴一部分有用的
 * <h3>Not supported in {@code BeanPostProcessor} or {@code BeanFactoryPostProcessor}</h3>
 * <p>Note that actual injection is performed through a
 * {@link org.springframework.beans.factory.config.BeanPostProcessor
 * BeanPostProcessor} which in turn means that you <em>cannot</em>
 * use {@code @Autowired} to inject references into
 * {@link org.springframework.beans.factory.config.BeanPostProcessor
 * BeanPostProcessor} or
 * {@link org.springframework.beans.factory.config.BeanFactoryPostProcessor BeanFactoryPostProcessor}
 * types. Please consult the javadoc for the {@link AutowiredAnnotationBeanPostProcessor}
 * class (which, by default, checks for the presence of this annotation).
 *
 * @author Juergen Hoeller
 * @author Mark Fisher
 * @author Sam Brannen
 * @since 2.5
 * @see AutowiredAnnotationBeanPostProcessor
 * @see Qualifier
 * @see Value
 */
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
 
    /**
     * Declares whether the annotated dependency is required.
     * <p>Defaults to {@code true}.
     */
    boolean required() default true;
 
}

  1. 重点在注释里的一句

     Please consult the javadoc for the {@link AutowiredAnnotationBeanPostProcessor}

  1. AutowiredAnnotationBeanPostProcessor是Spring的后置处理器，专门处理@Autowired和@Value注解。查看AutowiredAnnotationBeanPostProcessor类，关注postProcessorMergedBeanDefiniton()方法、postProcessorPropertyValues()方法和构造器

    //Spring在每个Bean实例化的时候，调用populateBean进行属性注入的时候，即调用postProcessPropertyValues方法。
@Deprecated
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
    return postProcessProperties(pvs, bean, beanName);
}
 
 
//•Spring容器在每个Bean实例化之后，调用AutowiredAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法。
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
    metadata.checkConfigMembers(beanDefinition);
}
 
//AutowiredAnnotationBeanPostProcessor构造器
public AutowiredAnnotationBeanPostProcessor() {
    //后置处理器将处理@Autowire注解
    this.autowiredAnnotationTypes.add(Autowired.class);
    //后置处理器将处理@Value注解
    this.autowiredAnnotationTypes.add(Value.class);
    try {
        //后置处理器将处理javax.inject.Inject JSR-330注解
        this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
                ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
        logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
    }
    catch (ClassNotFoundException ex) {
        // JSR-330 API not available - simply skip.
    }
}
 
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    //获取指定类中autowire相关注解的元信息
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    try {
        //对Bean的属性进行自动注入
        metadata.inject(bean, beanName, pvs);
    }
    catch (BeanCreationException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    }
    return pvs;
}

    1. 查看对Bean的属性进行自动注入metadata.inject(bean, beanName, pvs);方法

    public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    Collection<InjectedElement> checkedElements = this.checkedElements;
    //要注入的字段集合
    Collection<InjectedElement> elementsToIterate = (checkedElements != null ? checkedElements : this.injectedElements);
    if (!elementsToIterate.isEmpty()) {
        for (InjectedElement element : elementsToIterate) {
            element.inject(target, beanName, pvs);
        }
    }
}

    1. 查看element.inject(target, beanName, pvs);方法

    protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)throws Throwable {
    if (this.isField) {
        Field field = (Field) this.member;
        ReflectionUtils.makeAccessible(field);
        field.set(target, getResourceToInject(target, requestingBeanName));
    }
    else {
        if (checkPropertySkipping(pvs)) {
            return;
        }
        try {
            Method method = (Method) this.member;
            ReflectionUtils.makeAccessible(method);
            method.invoke(target, getResourceToInject(target, requestingBeanName));
        }
        catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }
}

    这是element.inject(target, beanName, pvs);的原始方法，它还有两个子类自己实现的方法，如图：

image-20231017190036871

此案例是字段注入分析，查看AutowiredFieldElement

//AutowiredAnnotationBeanPostProcessor.java
 
    @Override
    protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
        //获取要注入的字段
        Field field = (Field) this.member;
        Object value;
        //如果字段的值有缓存
        if (this.cached) {
            //从缓存中获取字段值value
            value = resolvedCachedArgument(beanName, this.cachedFieldValue);
        }
        //没有缓存
        else {
            //创建一个字段依赖描述符
            DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
            desc.setContainingClass(bean.getClass());
            Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
            Assert.state(beanFactory != null, "No BeanFactory available");
            //获取容器中的类型转换器
            TypeConverter typeConverter = beanFactory.getTypeConverter();
            try {
                //核心！获取注入的值
                value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
            }
            catch (BeansException ex) {
                throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
            }
            //线程同步，确保容器中数据一致性
            synchronized (this) {
                //如果字段的值没有缓存
                if (!this.cached) {
                    //字段值不为null，并且required属性为true
                    if (value != null || this.required) {
                        this.cachedFieldValue = desc;
                        //为指定Bean注册依赖Bean
                        registerDependentBeans(beanName, autowiredBeanNames);
                        if (autowiredBeanNames.size() == 1) {
                            String autowiredBeanName = autowiredBeanNames.iterator().next();
                            //如果容器中有指定名称的Bean对象
                            if (beanFactory.containsBean(autowiredBeanName)) {
                                //依赖对象类型和字段类型匹配，默认按类型注入
                                if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                                    //创建一个依赖对象的引用，同时缓存
                                    this.cachedFieldValue = new ShortcutDependencyDescriptor(
                                            desc, autowiredBeanName, field.getType());
                                }
                            }
                        }
                    }
                    //如果获取的依赖关系为null，且获取required属性为false
                    else {
                        //将字段值的缓存设置为null
                        this.cachedFieldValue = null;
                    }
                    //容器已经对当前字段的值缓存
                    this.cached = true;
                }
            }
        }
        //如果字段值不为null
        if (value != null) {
            //显式使用JDK的反射机制，设置自动的访问控制权限为允许访问
            ReflectionUtils.makeAccessible(field);
            //为字段赋值
            field.set(bean, value);
        }
    }

从注解@Value/@Autowired中获取要注入的值，之后利用反射set到字段中。 重点就是怎么从注解中获取要注入的值，我们来看核心代码

value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
//DefaultListableBeanFactory.java
 
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
	@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
 
	descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
	if (Optional.class == descriptor.getDependencyType()) {
		return createOptionalDependency(descriptor, requestingBeanName);
	}
	else if (ObjectFactory.class == descriptor.getDependencyType() ||
			ObjectProvider.class == descriptor.getDependencyType()) {
		return new DependencyObjectProvider(descriptor, requestingBeanName);
	}
	else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
		return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
	}
	else {
		Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
				descriptor, requestingBeanName);
		if (result == null) {
			//真正获取值的代码
			result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
		}
		return result;
	}
	}

进行跟踪：

//DefaultListableBeanFactory.java
 
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
	@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
 
	InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
	try {
		Object shortcut = descriptor.resolveShortcut(this);
		if (shortcut != null) {
			return shortcut;
		}
 
		//获取字段属性的类型
		Class<?> type = descriptor.getDependencyType();
 
		//拿到@Value里的值
		Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
		if (value != null) {
			if (value instanceof String) {
				String strVal = resolveEmbeddedValue((String) value);
				BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
				value = evaluateBeanDefinitionString(strVal, bd);
			}
			TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
			return (descriptor.getField() != null ?
					converter.convertIfNecessary(value, type, descriptor.getField()) :
					converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
		}
 
		//如果标识@Autowired注解的属性是集合类型，Array,Collection,Map,
		// 从这个方法获取@Autowired里的值
<1>		Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
		if (multipleBeans != null) {
			return multipleBeans;
		}
 
		//如果标识@Autowired注解的属性是非集合类型，
		// 从这个方法获取@Autowired里的值
<2>		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
		//如果没有符合该类型的Bean
		if (matchingBeans.isEmpty()) {
			//是否是必须的
			if (isRequired(descriptor)) {
				//抛出异常
				raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
			}
			return null;
		}
 
		String autowiredBeanName;
		Object instanceCandidate;
 
		//如果符合该类型的Bean有多个
		if (matchingBeans.size() > 1) {
			//挑选出最优解
<3>			autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
			if (autowiredBeanName == null) {
				if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
					//抛出异常
					return descriptor.resolveNotUnique(type, matchingBeans);
				}
				else {
					// In case of an optional Collection/Map, silently ignore a non-unique case:
					// possibly it was meant to be an empty collection of multiple regular beans
					// (before 4.3 in particular when we didn't even look for collection beans).
					return null;
				}
			}
			instanceCandidate = matchingBeans.get(autowiredBeanName);
		}
		else {
			// We have exactly one match.
			Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
			autowiredBeanName = entry.getKey();
			instanceCandidate = entry.getValue();
		}
 
		if (autowiredBeanNames != null) {
			autowiredBeanNames.add(autowiredBeanName);
		}
		if (instanceCandidate instanceof Class) {
			instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
		}
		Object result = instanceCandidate;
		if (result instanceof NullBean) {
			if (isRequired(descriptor)) {
				raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
			}
			result = null;
		}
		if (!ClassUtils.isAssignableValue(type, result)) {
			throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
		}
		return result;
	}
	finally {
		ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
	}
	}

大致流程就是： 根据字段类型从IOC容器中获取符合的Bean，如果有多个，则挑选出最优的那一个。

<1>处：@Autowired注入集合数组，如Map.List。

<2>处：@Autowired注入非集合数组,即普通的类如Service

<3>处：多个同类型的bean中挑选出最优解

总结：

    在容器启动，为bean属性赋值的时候，spring会用后置处理器AutowiredAnnotationBeanPostProcessor解析@Autowired注解，来创建属性的实例，然后从IOC容器中根据@Primary、@Order、@PriorityOrder或Spring默认规则挑选出最符合的Bean,利用反射注入到字段中完成赋值；
卡布叻_相超
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java注解机制之Spring自动装配实现原理详解
08-29
Java注解机制之Spring自动装配实现原理详解 Java注解机制是Java语言中的一种元数据 Facility，提供了一种在编译期和运行期对Java代码进行标记和描述的机制， Spring框架中使用Java注解机制来实现自动装配功能。自动...
Spring 自动装配的二义性实例解析
08-25
Spring 框架中的自动装配机制是通过 @Autowired 注解来实现的，它可以将 Bean 应用注入到构造参数和属性中。但是，在自动装配中存在一个问题，即二义性实例解析问题。当有多个 Bean 匹配同一个结果时，Spring 就不...
spring自动装配原理
DQWERww的博客
07-23 7396
spring
Spring自动装配：解析原理与实践
良月柒
05-09 882
在传统的Spring开发中，我们需要在XML配置文件或Java配置类中显式地定义bean的依赖关系和装配规则。而自动装配则是一种更加方便的方式，它能够根据一定的规则，自动地将bean注入到容器中，无需手动配置。Spring自动装配是一项强大而又灵活的特性，能够极大地简化开发过程，提高代码的灵活性和可维护性。但在实践中也需要注意一些问题，并采取相应的措施来避免潜在的风险和困扰。希望本文能够帮助你更好地理解和应用Spring自动装配，从而提升项目开发的效率和质量。
spring框架自动装配的原理
weixin_47659827的博客
07-24 6847
包含@PropertySource，@ComponentScans，@Bean，@Import等注解，最主要的是@Import注解的解析。，refresh中有13个非常关键的方法，来完成整个Spring应用程序的启动，在自动装配过程中，会。,在这两个关键步骤中完成了自动装配的核心功能，前面的处理逻辑包含了。，在对象的构造方法中会进行某些参数的初始化工作，最主要的是。，在整个过程中有一个非常重要的方法，叫做load，，把所有包含@Import的注解都解析到，然后。等各个准备工作，方便后续进行调用。...
Spring Boot的自动装配原理
热门推荐
YING—country的博客
07-20 3万+
自动装配是springboot的核心，一般提到自动装配就会和springboot联系在一起。实际上SpringFramework早就实现了这个功能。SpringBoot只是在其基础上，通过SPI的方式，做了进一步优化。SpringBoot定义了一套接口规范，这套规范规定SpringBoot在启动时会扫描外部引用jar包中的文件，将文件中配置的类型信息加载到Spring容器（此处涉及到JVM类加载机制与Spring的容器知识），并执行类中定义的各种操作。...
Spring自动装配原理理解
Eskiii的博客
05-17 3594
Spring本质上就是一个管理程序应用的容器，而spring的一个核心功能就是自动装配，也就是在程序启动时就自动将应用所需的所有bean自动扫描、配置和装入到容器中去，方便程序的使用。 什么是SpringBoot自动装配？ SpringBoot 定义了一套接口规范，这套规范规定：SpringBoot 应用在启动时会扫描外部引用 jar 包中的META-INF/spring.factories文件，将文件中默认配置信息加载到 Spring 容器（此处涉及到 JVM 类加载机制与 Spring 的容器知识.
第六篇 Spring 自动装配
Java 技术专栏，从入门到精通，熟悉企业级开发
04-18 1276
Bean 与 Bean 之间建立依赖关系的行为称为“装配”，使用注解可以帮忙我们从繁琐的xml配置中解脱出来，完成Bean的自动装配。
Spring Boot自动装配原理(易懂)
总结分享
02-19 1万+
熟练使用Spring Boot那么自动装配原理的掌握是必不可少的
Spring自动装配机制原理，源码解析，API全解析
赵KK的博客
04-19 776
大家好，今天我要和大家分享一篇关于Spring自动装配机制原理，源码解析，API的博客文章。通过本文，我将带大家一起探索Spring自动装配机制的原理，深入剖析源码，并详细介绍相关的API使用方法。通过掌握这些知识，相信大家对Spring自动装配机制有了更深入的理解，为成为Java架构师打下了坚实的基础。Spring自动装配机制是Spring框架的核心特性之一，它能够自动将Bean注入到需要它的地方。通过这些步骤，Spring容器能够自动地管理和组装Bean之间的关系，极大地简化了我们的开发工作。
Spring Boot自动装配原理详解
Joker_ZJN的博客
01-16 2393
Spring Boot的自动装配和启动过程，全网最简洁清晰的原理拆解。
Spring注解实现自动装配过程解析
08-19
本文主要介绍了 Spring 框架中使用注解实现自动装配的过程和原理，通过示例代码对各种注解的使用进行了详细的介绍，旨在帮助读者更好地理解和应用 Spring 的自动装配机制。 首先，@Autowired 注解是 Spring 框架中...
Spring 自动装配及其注解
07-23
本文将深入探讨Spring自动装配的概念、类型以及常用的注解。 一、Spring自动装配的基本概念 自动装配是Spring IoC（控制反转）的一种实现方式，IoC意味着容器负责创建对象并管理它们的生命周期，包括对象之间的依赖...
Spring使用@Autowired注解自动装配
06-08
在这个主题中，我们将深入探讨`@Autowired`的工作原理、使用场景以及如何在Spring应用中有效地利用它。 ### 1. 什么是`@Autowired`注解？ `@Autowired`是Spring框架的一部分，它用于自动将依赖对象注入到需要它们的...
SpringCloud之使用 Nacos 实现高效购物车商品信息处理
Takumilove的博客
07-24 1182
通过上述步骤，我们成功实现了一个高效的购物车商品信息处理流程。使用 Nacos 来进行服务发现，并结合手写的负载均衡策略，确保了服务调用的高可用性和稳定性。这样不仅提升了系统的性能，还能给用户带来更好的购物体验。
SpringBoot添加密码安全配置以及Jwt配置
最新发布
qq_64468032的博客
07-25 885
然后修改之前的SecurityConfig配置类，里面的configure方法里面的.antMatchers里面追加的url是不需要验证就能进行使用的请求，比如登录注册等url请求的放开，需要的话可以一直追加。如果数据库中的密码没有加密，可以通过测试类将密码进行加密，然后用加密之后的字符串与数据库中的数据进行替换即可。通过以下操作可以直接从token中获取用户的信息，然后通过用户的信息进行验证并返回用户需要的信息。在没有配置的情况下，默认用户名为 user ，密码在控制台中查找（如下）。
Java面试八股之Spring容器的启动流程
u012151345的博客
07-23 1068
在整个过程中，Spring遵循了IoC（控制反转）和DI（依赖注入）原则，确保Bean的创建、配置、组装和管理都在容器的统一控制之下，实现了松耦合和可扩展的软件架构。创建BeanDefinition：解析配置信息的过程中，Spring会为每个Bean生成对应的BeanDefinition对象，它包含了Bean的类型、构造方法参数、属性值、初始化方法、依赖关系、作用域、生命周期回调方法等所有相关信息。Spring容器的启动流程涉及一系列有序的操作，以确保容器正确初始化并准备好管理应用程序中的Bean。
spring自动装配的原理
08-08
Spring 的自动装配原理是基于依赖注入（Dependency Injection，简称 DI）实现的。它主要通过以下方式实现自动装配： 1. 组件扫描：Spring 容器会扫描指定包下的所有类，查找带有特定注解（如 @Component、@Service...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值