spring @Component原理及自定义实现

已于 2022-04-27 19:30:41 修改
阅读量1.4k 收藏 1
点赞数
分类专栏： spring aop 文章标签： spring aop
于 2022-04-27 10:27:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43931625/article/details/124444967
版权

spring @Component原理及自定义实现

         

            

                                         

@Component 原理

        

@Component扫描注册调用栈

# ClassPathBeanDefinitionScanner类
at org.springframework.context.annotation.ClassPathBeanDefinitionScanner.doScan(ClassPathBeanDefinitionScanner.java:280)

# ComponentScanAnnotationParser类
at org.springframework.context.annotation.ComponentScanAnnotationParser.parse(ComponentScanAnnotationParser.java:128)

# ConfigurationClassParser类
at org.springframework.context.annotation.ConfigurationClassParser.doProcessConfigurationClass(ConfigurationClassParser.java:296)
at org.springframework.context.annotation.ConfigurationClassParser.processConfigurationClass(ConfigurationClassParser.java:250)
at org.springframework.context.annotation.ConfigurationClassParser.parse(ConfigurationClassParser.java:207)
at org.springframework.context.annotation.ConfigurationClassParser.parse(ConfigurationClassParser.java:175)

# ConfigurationClassPostProcessor类
at org.springframework.context.annotation.ConfigurationClassPostProcessor.processConfigBeanDefinitions(ConfigurationClassPostProcessor.java:331)
at org.springframework.context.annotation.ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry(ConfigurationClassPostProcessor.java:247)

# PostProcessorRegistrationDelegate类
at org.springframework.context.support.PostProcessorRegistrationDelegate.invokeBeanDefinitionRegistryPostProcessors(PostProcessorRegistrationDelegate.java:311)
at org.springframework.context.support.PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(PostProcessorRegistrationDelegate.java:112)

# AbstractApplicationContext类
at org.springframework.context.support.AbstractApplicationContext.invokeBeanFactoryPostProcessors(AbstractApplicationContext.java:746)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:564)
	  - locked <0xe7b> (a java.lang.Object)

# ServletWebServerApplicationContext类
at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:145)

# SpringApplication类
at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:740)
at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:415)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:303)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1312)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1301)

# 项目启动入口
at com.example.demo.DemoApplication.main(DemoApplication.java:16)

           

ComponentScan

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};      //指定扫描的包

    @AliasFor("value")
    String[] basePackages() default {}; //与value等效

    Class<?>[] basePackageClasses() default {};   //指定扫描的类

    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
                                        //指定beanName生成器

    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;

    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;

    String resourcePattern() default "**/*.class";

    boolean useDefaultFilters() default true;     //是否使用默认的过滤器
    ComponentScan.Filter[] includeFilters() default {};  //包含的过滤器
    ComponentScan.Filter[] excludeFilters() default {};  //排除的过滤器

    boolean lazyInit() default false;

    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
        FilterType type() default FilterType.ANNOTATION;  //默认注解过滤

        @AliasFor("classes")
        Class<?>[] value() default {};    //可以设置自定义过滤器

        @AliasFor("value")
        Class<?>[] classes() default {};

        String[] pattern() default {};
    }
}

            

FilterType

public enum FilterType {
    ANNOTATION,       //指定的注解类（可以是自定义的注解类）
    ASSIGNABLE_TYPE,  //过滤指定的类
    ASPECTJ,  //aspectJ表达式
    REGEX,    //正则表达式
    CUSTOM;   //自定义过滤器（自定义匹配规则）

    private FilterType() {
    }
}

           

TypeFilter：实现该接口，可自定义过滤匹配规则

@FunctionalInterface
public interface TypeFilter {
    boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException;
}

                            

@ComponentScan使用示例

@ComponentScan(includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {CustomComponent.class}), 
                             //标注了@CustomComponent注解的类会被注册
        @ComponentScan.Filter(type = FilterType.REGEX, pattern = "com.example.demo.service..*"),
                             //扫描注册正则表达式匹配的类
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {CustomFilter.class}),
                             //自定义类过滤器，匹配的类会被扫描注册
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {HelloServiceImpl.class})
                             //扫描注册指定的类
})

           

ComponentScanParser：根据@ComponentScan注解扫描注册类

class ComponentScanAnnotationParser {
    private final Environment environment;
    private final ResourceLoader resourceLoader;
    private final BeanNameGenerator beanNameGenerator;
    private final BeanDefinitionRegistry registry;

    public ComponentScanAnnotationParser(Environment environment, ResourceLoader resourceLoader, BeanNameGenerator beanNameGenerator, BeanDefinitionRegistry registry) {
        this.environment = environment;
        this.resourceLoader = resourceLoader;
        this.beanNameGenerator = beanNameGenerator;
        this.registry = registry;
    }

    public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, String declaringClass) {
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
        Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
        boolean useInheritedGenerator = BeanNameGenerator.class == generatorClass;
        scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator : (BeanNameGenerator)BeanUtils.instantiateClass(generatorClass));
                //设置beanName生成器
        ScopedProxyMode scopedProxyMode = (ScopedProxyMode)componentScan.getEnum("scopedProxy");
        if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
            scanner.setScopedProxyMode(scopedProxyMode);
        } else {
            Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
            scanner.setScopeMetadataResolver((ScopeMetadataResolver)BeanUtils.instantiateClass(resolverClass));
        }

        scanner.setResourcePattern(componentScan.getString("resourcePattern"));
        AnnotationAttributes[] var15 = componentScan.getAnnotationArray("includeFilters");
        int var8 = var15.length;

        int var9;
        AnnotationAttributes excludeFilterAttributes;
        List typeFilters;
        Iterator var12;
        TypeFilter typeFilter;
        for(var9 = 0; var9 < var8; ++var9) {
            excludeFilterAttributes = var15[var9];
            typeFilters = TypeFilterUtils.createTypeFiltersFor(excludeFilterAttributes, this.environment, this.resourceLoader, this.registry);
            var12 = typeFilters.iterator();

            while(var12.hasNext()) {
                typeFilter = (TypeFilter)var12.next();
                scanner.addIncludeFilter(typeFilter);
            }   //添加include过滤器
        }

        var15 = componentScan.getAnnotationArray("excludeFilters");
        var8 = var15.length;

        for(var9 = 0; var9 < var8; ++var9) {
            excludeFilterAttributes = var15[var9];
            typeFilters = TypeFilterUtils.createTypeFiltersFor(excludeFilterAttributes, this.environment, this.resourceLoader, this.registry);
            var12 = typeFilters.iterator();

            while(var12.hasNext()) {
                typeFilter = (TypeFilter)var12.next();
                scanner.addExcludeFilter(typeFilter);
            }   //添加exclude过滤器
        }

        boolean lazyInit = componentScan.getBoolean("lazyInit");
        if (lazyInit) {
            scanner.getBeanDefinitionDefaults().setLazyInit(true);
        }

        Set<String> basePackages = new LinkedHashSet();
        String[] basePackagesArray = componentScan.getStringArray("basePackages");
        String[] var19 = basePackagesArray;
        int var21 = basePackagesArray.length;

        int var22;
        for(var22 = 0; var22 < var21; ++var22) {
            String pkg = var19[var22];
            String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg), ",; \t\n");
            Collections.addAll(basePackages, tokenized);
        }

        Class[] var20 = componentScan.getClassArray("basePackageClasses");
        var21 = var20.length;

        for(var22 = 0; var22 < var21; ++var22) {
            Class<?> clazz = var20[var22];
            basePackages.add(ClassUtils.getPackageName(clazz));
        }

        if (basePackages.isEmpty()) {
            basePackages.add(ClassUtils.getPackageName(declaringClass));
        }

        scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
            protected boolean matchClassName(String className) {
                return declaringClass.equals(className);
            }
        });
        return scanner.doScan(StringUtils.toStringArray(basePackages));
    }                  //扫描指定的包
}

           

ClassPathBeanDefinitionScanner：扫描注册beanDefinition

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
    private final BeanDefinitionRegistry registry;
    private BeanDefinitionDefaults beanDefinitionDefaults;
    @Nullable
    private String[] autowireCandidatePatterns;
    private BeanNameGenerator beanNameGenerator;
    private ScopeMetadataResolver scopeMetadataResolver;
    private boolean includeAnnotationConfig;


    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) {
    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, @Nullable ResourceLoader resourceLoader) {


    public final BeanDefinitionRegistry getRegistry() {
    public BeanDefinitionDefaults getBeanDefinitionDefaults() {

    public void setBeanDefinitionDefaults(@Nullable BeanDefinitionDefaults beanDefinitionDefaults) {
    public void setAutowireCandidatePatterns(@Nullable String... autowireCandidatePatterns) {

    public void setScopeMetadataResolver(@Nullable ScopeMetadataResolver scopeMetadataResolver) {
    public void setScopedProxyMode(ScopedProxyMode scopedProxyMode) {
    public void setIncludeAnnotationConfig(boolean includeAnnotationConfig) {
    public void setBeanNameGenerator(@Nullable BeanNameGenerator beanNameGenerator) {


    public int scan(String... basePackages) {   //扫描指定目录包下的类
        int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
        this.doScan(basePackages);  //执行具体扫描操作
        if (this.includeAnnotationConfig) {
            AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
        }

        return this.registry.getBeanDefinitionCount() - beanCountAtScanStart;
    }

    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet();
        String[] var3 = basePackages;
        int var4 = basePackages.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String basePackage = var3[var5];
            Set<BeanDefinition> candidates = this.findCandidateComponents(basePackage);
                                                    //查找component注解类
            Iterator var8 = candidates.iterator();

            while(var8.hasNext()) {
                BeanDefinition candidate = (BeanDefinition)var8.next();
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                                   //生成beanName，后续用来注册bean
                if (candidate instanceof AbstractBeanDefinition) {
                    this.postProcessBeanDefinition((AbstractBeanDefinition)candidate, beanName);
                }

                if (candidate instanceof AnnotatedBeanDefinition) {
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition)candidate);
                }

                if (this.checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    this.registerBeanDefinition(definitionHolder, this.registry);
                }   //注册bean信息
            }
        }

        return beanDefinitions;
    }

    protected void postProcessBeanDefinition(AbstractBeanDefinition beanDefinition, String beanName) {
    protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
    protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {
    protected boolean isCompatible(BeanDefinition newDefinition, BeanDefinition existingDefinition) {

    private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {

          

AnnotationBeanNameGenerator：注解标注的类生成beanName

public class AnnotationBeanNameGenerator implements BeanNameGenerator {
    public static final AnnotationBeanNameGenerator INSTANCE = new AnnotationBeanNameGenerator();
    private static final String COMPONENT_ANNOTATION_CLASSNAME = "org.springframework.stereotype.Component";
    private final Map<String, Set<String>> metaAnnotationTypesCache = new ConcurrentHashMap();

    public AnnotationBeanNameGenerator() {
    }

    public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
        if (definition instanceof AnnotatedBeanDefinition) {  //如果是注解标注的类
            String beanName = this.determineBeanNameFromAnnotation((AnnotatedBeanDefinition)definition);
                                //生成beanName
            if (StringUtils.hasText(beanName)) {
                return beanName;
            }   //如果注解中设置了value（beanname），且不为空，则直接返回
        }

        return this.buildDefaultBeanName(definition, registry); 
                   //如果没有设置，通过类名获取beanName
    }

    @Nullable
    protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
        AnnotationMetadata amd = annotatedDef.getMetadata();
        Set<String> types = amd.getAnnotationTypes();
        String beanName = null;
        Iterator var5 = types.iterator();

        while(var5.hasNext()) {
            String type = (String)var5.next();
            AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
            if (attributes != null) {
                Set<String> metaTypes = (Set)this.metaAnnotationTypesCache.computeIfAbsent(type, (key) -> {
                    Set<String> result = amd.getMetaAnnotationTypes(key);
                    return result.isEmpty() ? Collections.emptySet() : result;
                });
                if (this.isStereotypeWithNameValue(type, metaTypes, attributes)) {
                    Object value = attributes.get("value");   //读取注解value设置的值
                    if (value instanceof String) {
                        String strVal = (String)value;
                        if (StringUtils.hasLength(strVal)) {
                            if (beanName != null && !strVal.equals(beanName)) {
                                throw new IllegalStateException("Stereotype annotations suggest inconsistent component names: '" + beanName + "' versus '" + strVal + "'");
                            }

                            beanName = strVal;
                        }
                    }
                }
            }
        }

        return beanName;
    }

    protected boolean isStereotypeWithNameValue(String annotationType, Set<String> metaAnnotationTypes, @Nullable Map<String, Object> attributes) {
        boolean isStereotype = annotationType.equals("org.springframework.stereotype.Component") || metaAnnotationTypes.contains("org.springframework.stereotype.Component") || annotationType.equals("javax.annotation.ManagedBean") || annotationType.equals("javax.inject.Named");
        return isStereotype && attributes != null && attributes.containsKey("value");
    }

    protected String buildDefaultBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
        return this.buildDefaultBeanName(definition);
    }

    protected String buildDefaultBeanName(BeanDefinition definition) {
        String beanClassName = definition.getBeanClassName();
        Assert.state(beanClassName != null, "No bean class name set");
        String shortClassName = ClassUtils.getShortName(beanClassName);
        return Introspector.decapitalize(shortClassName);
    }   //截取类名获取beanName
}

        

                   

                                         

自定义注解

      

                          

         

CustomComponent

@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomComponent {

    String value() default "";
}

       

HelloService

public interface HelloService {

    String hello();
}

        

HelloServiceImpl

@CustomComponent
public class HelloServiceImpl implements HelloService {

    @Override
    public String hello() {
        return "hello";
    }
}

          

HelloController

@RestController
public class HelloController {

    @Resource
    private HelloService helloService;

    @RequestMapping("/hello")
    public String hello(){
        System.out.println(helloService.hello());

        return "hello";
    }
}

        

DemoApplication

@SpringBootApplication
@ComponentScan(includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {CustomComponent.class})
})      //设置自定义注解
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

        

localhost:8080/hello：启动应用，控制台输出

2022-04-27 19:18:13.847  INFO 5271 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 787 ms
2022-04-27 19:18:14.126  INFO 5271 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2022-04-27 19:18:14.134  INFO 5271 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 1.412 seconds (JVM running for 1.837)
2022-04-27 19:18:16.373  INFO 5271 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2022-04-27 19:18:16.373  INFO 5271 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2022-04-27 19:18:16.374  INFO 5271 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
hello

         

              

o_瓜田李下_o
关注
专栏目录
老生谈spring（十一）：自定义标签之component-scan
JankeDeng的博客
09-15 350
资深小白谈spring（十一）：自定义标签之component-scan 1、上一节讲到了spring通过resolve方法解析spring.handlers文件得到context的解析类，现在接着来看resolve方法。反射得到这个handler类以后用BeanUtils创建这个类的实例，调用init方法后放到handlerMappings容器中。 2、以context:component-scan为例，我们知道context的命名空间是由ContextNamespaceHandler来负责处理的，那么我
spring @Value原理及自定义实现
weixin_43931625的博客
04-25 1909
spring @Value原理及自定义实现
Spring中@component的使用
热门推荐
不怕万人阻挡，只怕自己投降
06-09 20万+
Spring中@component的使用 @component是spring中的一个注解，它的作用就是实现bean的注入，@component取代。在探究@component前先了解一下注解？何为注解？注解本质上就是一个类，开发中我们可以使用注解 取代 xml配置文件。 web开发，提供3个@Component注解衍生注解（功能一样）取代 @Repository(“名称”)：dao层 @Servi...
Spring中@Component的作用
博客
11-17 20万+
@controller 、@servies、@respository、@Component
SpringComponent 介绍
管子（zero）的杂乱空间
07-07 386
SpringComponent 是org.restlet.ext.spring 包中继承了 Component 的一个用于在spring环境下使用的Component子类。 SpringComponent 提供了一个 client 和多个 client、一个server和多个server，以及defaultTarget的注入接口。 为 defaultTarget 属性赋值在 Spring 环境下...
Spring Framework 组件注册 之 @Component
azj808237400的博客
06-27 129
Spring Framework 组件注册 之 @Component 写在前面 在spring大行其道的今天，对于spring的使用和掌握乃是不可缺少的必备技能。但是spring的整个体系尤为庞大，对它的学习，还得从基础一点一滴的慢慢积累。本文主要介绍@Component注解在spring中的简单使用，以及注解的派生性和层次性 @Component 简单使用 @Component注解...
spring @Value注解原理梳理及自定义实现@MyValue注解实例
mapeng765441650的博客
04-13 8434
spring @Value注解原理梳理及自定义实现@MyValue注解 目录 @Value注解如何使用？ 探索@Value注解的实现过程 自定义实现@MyValue注解 1. @Value注解如何使用? 在项目中我们经常需要用到使用读取配置文件，进行属性值的注入很方便； 很多时候我们不想手动的去初始化配置，在spring就提供了很强大的属性依赖配置注解@Value来实现，在实现bean创建后...
如何实现 Spring 的 @Component 注解
Meldoy_mgh的博客
02-14 1402
mghio读完需要36分钟速读仅需 12 分钟 前言前面两篇文章（如何实现一个简易版的 Spring - 如何实现 Setter 注入、如何实现一个简易版的 Spring - 如何实现...
这一次搞懂Spring自定义标签以及注解解析原理说明
09-07
总结起来，Spring的自定义标签解析是通过`NamespaceHandler`机制实现的，而注解解析则依赖于类路径扫描和`BeanDefinition`的创建。这两者都是Spring实现声明式编程和依赖注入的重要组成部分，极大地简化了Spring应用...
如何实现一个简易版的 Spring - 如何实现 @Component 注解
Meldoy_mgh的博客
02-14 497
前言 前面两篇文章（如何实现一个简易版的 Spring - 如何实现 Setter 注入、如何实现一个简易版的 Spring - 如何实现 Constructor 注入）介绍的都是基于 XML 配置文件方式的实现，从 JDK 5 版本开始 Java 引入了注解支持，带来了极大的便利，Sprinng 也从 2.5 版本开始支持注解方式，使用注解方式我们只需加上相应的注解即可，不再需要去编写繁琐的 XML 配置文件，深受广大 Java 编程人员的喜爱。接下来一起看看如何实现 Spring 框架中最常用的两个注解
spring之注解（三）Component
我的山水
03-21 3万+
上篇文章中比较详细的介绍了依赖注入的相关注解，尤其是@Autowired。但是我们对bean的定义声明还是放在xml的配置文件中。Spring当然提供了机制可以自动的扫描类路径，自动的向容器注册BeanDefinition。这就是Bean级别的注解。以上机制称为类路径扫描（clsspath-sacn），它是有相关注解（如@Component @Named @Bean）和beanFactoryPos
【Spring-注解学习】@Component
daohangtaiqian的博客
03-01 1043
@Component
Spring的@component
qq_45818465的博客
03-05 327
Spring的@component 1、@component （把普通pojo实例化到spring容器中，相当于配置文件中的 本来后三个就是对@component 的扩展，后面版本的spring可能（可能）会给这三个标签加更多的功能。目前版本用起来都一样，只是看起来更加容易区分。 <bean id="" class=""/>） 泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类。 案例：
spring @component 详解
lovezhaohaimig的博客
11-08 6212
1、@controller 控制器（注入服务） 2、@service 服务（注入dao） 3、@repository dao（实现dao访问） 4、@component （把普通pojo实例化到spring容器中，相当于配置文件中的） @Component,@Service,@Controller,@Repository注解的类，并把这些类纳入进spring容器中管理。 下面写这个是引入co
Spring--@Component的原理
IT利刃出鞘的博客
06-02 1867
@Component原理 其他网址 Spring注解Component原理源码解析 - Griez - 博客园 简介 我们经常使用Spring的@Component、@Service、@Repository以及 @Controller等注解来实现bean托管给Spring容器管理。Spring是怎么样实现的呢？我们一起跟着源码看看整个过程吧！ 先看调用时序图： 概述@Component到Spring bean容器管理过程。 第一步，初始化时设置了Component类型...
Springboot中自定义组件
程序三两行
03-11 1956
spring是是通过xml给容器添加组件的，在Springboot可以通过@configuration配置类的方式添加组件@Configuration //告诉boot这是一个配置类，相当于Spring中的配置文件/***1、通过配置类给容器添加组件 方法名作为组件的id返回类型就是组件的类型 返回的值就是组件在容器中的实列*2、如果不想让方法名作为组件id 可以在bean注解中传参*3、无论对这个方法调用多少次 获取到的都是之前注册进容器中的单实例对象*/@Bean。
【spring】@Component注解学习
最新发布
一个写了10年bug的程序员日常笔记。
03-22 2794
Component 是 Spring 框架中的一个注解，用于将一个类标记为 Spring 上下文中的一个组件。当一个类被标记为 @Component 时，Spring 容器会在启动时自动扫描并实例化这个类，并将其注册到 Spring 上下文中。@Component 注解可以用于任何类，包括控制器、服务、DAO 等。当一个类被标记为 @Component 时，它就成为了 Spring 上下文中的一个 bean，可以被其他 bean 通过依赖注入的方式使用。
Spring @Component注解
Alecor的博客
10-09 513
基本的就不一一介绍了，直接进入主题 @controller 控制器（注入服务） @service 服务（注入dao） @repository dao（实现dao访问） @component （把普通pojo实例化到spring容器中，相当于配置文件中的 " &lt;Bean id ="" class ="" / &gt; "） @Component,@Service,@Con...
深入解析@Component注解在Spring Boot中的应用
总之，深入理解@Component注解，不仅可以帮助开发者更好地掌握Spring Boot框架的原理，还可以有效地管理和优化Spring应用程序的资源。通过对@Component及其衍生注解的灵活运用，开发者可以构建出既高效又可维护的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值