spring5.0源码-注解阅读笔记

最新推荐文章于 2024-01-30 16:56:47 发布
最新推荐文章于 2024-01-30 16:56:47 发布
阅读量529 收藏 1
点赞数
分类专栏： java 源码学习 Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shzm0/article/details/85227569
版权
java 同时被 3 个专栏收录
17 篇文章 1 订阅
订阅专栏
源码学习
4 篇文章 0 订阅
订阅专栏
Spring
4 篇文章 0 订阅
订阅专栏

Spring 注解扫描怎么实现
通过注解，如何实现事务
注解：

用一个词就可以描述注解，那就是元数据，即一种描述数据的数据。所以，可以说注解就是源代码的元数据。JDK1.5以后提供

java建立自定义注解的一些必须知道的参数
@Documented –注解是否将包含在JavaDoc中
@Retention –什么时候使用该注解
@Target? –注解用于什么地方
@Inherited – 是否允许子类继承该注解

@Documented–一个简单的Annotations标记注解，表示是否将注解信息添加在java文档中。

@Retention– 定义该注解的生命周期。

RetentionPolicy.SOURCE – 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。

RetentionPolicy.CLASS – 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式。

RetentionPolicy.RUNTIME– 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

@Target – 表示该注解用于什么地方。如果不明确指出，该注解可以放在任何地方。以下是一些可用的参数。需要说明的是：属性的注解是兼容的，如果你想给7个属性都添加注解，仅仅排除一个属性，那么你需要在定义target包含所有的属性。

ElementType.TYPE:用于描述类、接口或enum声明
ElementType.FIELD:用于描述实例变量
ElementType.METHOD
ElementType.PARAMETER
ElementType.CONSTRUCTOR
ElementType.LOCAL_VARIABLE
ElementType.ANNOTATION_TYPE 另一个注释
ElementType.PACKAGE 用于记录java文件的package信息

@Inherited – 定义该注释和子类的关系

我们这里就以
@Autowired和@transactional 2个注解来分析
先看@Autowired这个注解

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

这里看出Autowired支持了方法，字段，函数等目标，生命周期一直拥有，添加到java文档
看下XML配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.cn.yc" />
</beans>

这个和上章套路差不多，通过xmlns:context找到，执行类，具体执行查spring.handlers这里
直接看方法把

public class ContextNamespaceHandler extends NamespaceHandlerSupport {
    public ContextNamespaceHandler() {
    }

    public void init() {
        this.registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
        this.registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
        this.registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
        //别跑，就是你了，将component注册掉
        this.registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
        this.registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
        this.registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
        this.registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
        this.registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
    }
}

ComponentScanBeanDefinitionParser这个类的关键代码

 @Nullable
    public BeanDefinition parse(Element element, ParserContext parserContext) {
       //解析 base-package
        String basePackage = element.getAttribute("base-package");
        basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
        String[] basePackages = StringUtils.tokenizeToStringArray(basePackage, ",; \t\n");
        //定义扫描类信息
        ClassPathBeanDefinitionScanner scanner = this.configureScanner(parserContext, element);
        //查找bean
        Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
        //然后将bean进行进一步处理，也就是
        this.registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
        return null;
    }

在这里插入图片描述

直接去关键类ClassPathScanningCandidateComponentProvider查找bean

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    LinkedHashSet candidates = new LinkedHashSet();

    try {
        String packageSearchPath = "classpath*:" + this.resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        //这里是查找到所有class
        Resource[] resources = this.getResourcePatternResolver().getResources(packageSearchPath);
        boolean traceEnabled = this.logger.isTraceEnabled();
        boolean debugEnabled = this.logger.isDebugEnabled();
        Resource[] var7 = resources;
        int var8 = resources.length;
        //这个for循环，判断每个class是不是组件
        for(int var9 = 0; var9 < var8; ++var9) {
            Resource resource = var7[var9];
            if (traceEnabled) {
                this.logger.trace("Scanning " + resource);
            }

            if (resource.isReadable()) {
                try {
                    MetadataReader metadataReader = this.getMetadataReaderFactory().getMetadataReader(resource);
                    if (this.isCandidateComponent(metadataReader)) {
                        ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                        sbd.setResource(resource);
                        sbd.setSource(resource);
                        if (this.isCandidateComponent((AnnotatedBeanDefinition)sbd)) {
                            if (debugEnabled) {
                                this.logger.debug("Identified candidate component class: " + resource);
                            }

                            candidates.add(sbd);
                        } else if (debugEnabled) {
                            this.logger.debug("Ignored because not a concrete top-level class: " + resource);
                        }
                    } else if (traceEnabled) {
                        this.logger.trace("Ignored because not matching any filter: " + resource);
                    }
                } catch (Throwable var13) {
                    throw new BeanDefinitionStoreException("Failed to read candidate component class: " + resource, var13);
                }
            } else if (traceEnabled) {
                this.logger.trace("Ignored because not readable: " + resource);
            }
        }

        return candidates;
    } catch (IOException var14) {
        throw new BeanDefinitionStoreException("I/O failure during classpath scanning", var14);
    }
}


private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
	Set<BeanDefinition> candidates = new LinkedHashSet<>();
	try {
		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
				resolveBasePackage(basePackage) + '/' + this.resourcePattern;
		 //这里是查找到所有class
		Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
		boolean traceEnabled = logger.isTraceEnabled();
		boolean debugEnabled = logger.isDebugEnabled();
		 //这个for循环，判断每个class是不是组件
		for (Resource resource : resources) {
			if (traceEnabled) {
				logger.trace("Scanning " + resource);
			}
			if (resource.isReadable()) {
				try {
					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);
							}
							//放到list里面
							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) {
					throw new BeanDefinitionStoreException(
							"Failed to read candidate component class: " + resource, ex);
				}
			}
			else {
				if (traceEnabled) {
					logger.trace("Ignored because not readable: " + resource);
				}
			}
		}
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
	}
	return candidates;
}

放到Set进行返回，这里注意是set，也就是说bean必须唯一
现在再反过来看doScan这个函数

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
	Assert.notEmpty(basePackages, "At least one base package must be specified");
	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
	for (String basePackage : basePackages) {
		//拿到所有定义了注解的bean
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
		for (BeanDefinition candidate : candidates) {
			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
			candidate.setScope(scopeMetadata.getScopeName());
			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
			if (candidate instanceof AbstractBeanDefinition) {
				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
			}
			//这里是一个公共的注解判断，Lazy，DependsOn，Role，Description
			if (candidate instanceof AnnotatedBeanDefinition) {
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
			if (checkCandidate(beanName, candidate)) {
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				definitionHolder =
						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				beanDefinitions.add(definitionHolder);
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}

将所有的bean注册好，放回去，这个时候bean已经注册ok，然后放到上下文中
但是@Autowired啥时候生效了？

 this.registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

//这个就是给所有注解的后续处理代码

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
      BeanDefinitionRegistry registry, @Nullable Object source) {

   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
   if (beanFactory != null) {
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
      }
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
         beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
      }
   }

   Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

   if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
   }
   
   if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
          //就是这个类去执行的，为什么是这个类，源码文档上面有一个@See,这样子定位简单一点，不然真要吐血
      RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
   if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
   if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition();
      try {
         def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
               AnnotationConfigUtils.class.getClassLoader()));
      }
      catch (ClassNotFoundException ex) {
         throw new IllegalStateException(
               "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
      }
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
   }

   return beanDefs;
}

这里只是放进去执行类，但是不在这里执行，构造和执行，分别在refresh（）里面的其他方法，这里不做展开了，直接看@Autowired怎么执行的吧

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
   // Fall back to class name as cache key, for backwards compatibility with custom callers.
   String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
   // Quick check on the concurrent map first, with minimal locking.
   InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
   if (InjectionMetadata.needsRefresh(metadata, clazz)) {
      synchronized (this.injectionMetadataCache) {
         metadata = this.injectionMetadataCache.get(cacheKey);
         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            if (metadata != null) {
               metadata.clear(pvs);
            }
                       //找到类，然后实例化
            metadata = buildAutowiringMetadata(clazz);
            //放到concureentHashmap里面
            this.injectionMetadataCache.put(cacheKey, metadata);
         }
      }
   }
   return metadata;
}

然后后面取的时候会从cace里面查一次，autowired解析完毕

松影
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-framework:带中文注释的spring5的源码解析，spring5源码来源https
03-23
Spring框架 这是Spring框架的所在地：所有的基础。 总体来说，Spring框架和Spring项目系列通常简称为“ Spring”。 Spring提供了Java编程语言以外的所有所需内容，可用于为各种场景和体系结构创建企业应用程序。 请阅读部分作为参考，以获取更完整的介绍。 行为守则 该项目受《。 通过参与，您将遵守此行为准则。 请向报告不可接受的行为。 访问二进制文件 有关对工件或发行版zip的访问，请参见 Wiki页面。 文献资料 Spring框架维护参考文档（ 和），Github 以及。 在整个Spring项目中也有。 从源构建 请参阅Wikipedia页面和文件。 保持联系 在Twitter上关注 ， 及其。 可以在上找到深入的文章，并通过我们的宣布其。 执照 Spring框架是在2.0版下。
Spring注解及源码分析
CLAY
04-08 1705
本文记录自己学习spring注解驱动开发教程笔记 参考： 1、https://blog.csdn.net/yerenyuan_pku/category_10613855.html 2、B站视频 12 如何使用@Bean注解指定初始化和销毁的方法 @Scope("prototype") @Bean(initMethod = "init",destroyMethod = "destroy") 一、什么情况使用？ 典型场景：数据源的管理（初始化的时候需要赋值，销毁的时候需要对连接进行关闭清..
Spring 5 Resource 源码注释
qq_30321211的博客
09-03 322
UML类图 Resource /** * Interface for a resource descriptor that abstracts from the actual * type of underlying resource, such as a file or class path resource. * <p> * 资源描述符的接口，该描述符从底层资源的实际类型中抽象出来，例如一个 * 文件或类路径资源 * </p> * <p&gt
Spring源码概览（注解版）
qq_38921029的博客
02-24 378
Spring源码解析，注解版！
Spring源码全解
weixin_38650898的博客
11-08 4433
文章目录1.容器简介什么是容器?IOC/DI2.容器的结构2.1 BeanFactory2.2 ApplicationContext2.2.1 ConfigurableApplicationContext2.2.2 WebApplicationContext3、ApplicationContext 启动流程3.1、prepareRefresh3.2、obtainFreshBeanFactory 1.容器简介 什么是容器? Java应用中，对象与对象之间往往存在各种复杂的依赖，对象的构建也会变得越来越复杂，如
spring 5.0 源码
08-17
深入理解Spring 5.0的源码，对于Java和Java EE开发者来说，是提升技术水平、优化代码设计、以及更好地驾驭复杂系统的关键。 首先，Spring 5.0对核心容器（Core Container）进行了升级，引入了响应式编程模型的支持...
spring-tx-5.0.0.0.RELEASE.jar_java开发_spring-tx-5.0.0_
09-30
Spring TX 5.0.0.0.RELEASE.jar中，@Transactional注解是其声明式事务管理的关键。这个版本可能对注解的性能进行了优化，同时可能修复了一些已知的问题，确保了更好的稳定性和兼容性。当一个带有@Transactional的...
spring5.0源码
01-19
6. **Spring Boot**：虽然不直接包含在Spring 5.0源码中，但Spring Boot是与之紧密相关的项目，它极大地简化了Spring应用的启动和配置，通过自动配置和起步依赖，让开发者能够快速地搭建和运行应用。 7. ** ...
spring-framework-5.0.x:spring原始阅读-spring源码阅读
03-24
请阅读参考中的“ 部分以获取更完整的介绍。 行为守则 该项目受《。 通过参与，您将遵守此守则。 请向报告不可接受的行为。 访问二进制文件 有关对工件或发行版zip的访问，请参见 Wiki页面。 文献资料 Spring ...
Spring注解源码解析一
qq_35873436的博客
03-21 1856
我们们之前对Spring容器的初始化和bean的加载过程都做了相应的分析，不过我们之前分析源码入口是xml配置和BeanFactory，在我们的实际项目中，现在都不使用xml配置bean了。我们更多的是使用Spring提供的各种注解，比如@Bean、@Controller、@Component、@Service、@Autowired等注解。所以我们从本节开始就要对这些注解源码进行分析了。 注解是什么呢？ 我们这里定义了一个名字叫做MyComponent的注解 其实，注解本质就是一个接口，只不过是继承了An
spring 源码中文注释
12-11
spring 源码解析
spring 编译后源码（有注释）
03-24
不需要编译，下下来就可以用，而且还带有中文注释的。拉拉啦
spring-framework-5.0.2.RELEASE-中文注释版源码
07-18
此源码配合我的另一个资源《Tom_深入分析Spring源码》这个下载的资源一起使用，里面注释的很详细，中文注释方便了很多英语不好的童鞋，跟着文档看着源码学spring源码效率很高，希望能帮助大家 《Tom_深入分析Spring源码》的下载地址： https://download.csdn.net/download/wal1314520/10544578
spring 5 中文注释源码.rar
01-13
新版 spring 5 中文注释源码,关键源码位置都有中文注释，方便阅读源码 spring源码解读 Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。
spring源码（注释+测试版）
03-23
spring源码（注释+测试版）
Spring注解开发源码解析
最新发布
Z2658172512的博客
01-30 1171
1：默认情况下，加在容器中的组件，在容器启动时就会调用无参构造函数来创建对象，然后初始化，把@Autowired标注在方法上，该方法如果有参数（组件），会使用autowired的方式（byType）在容器中查找是否有该组件。2：标注在带参构造函数上，如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件可以自动从容器中获取。原因：@Configuration这个注解的作用就是为MainConfig类加上Cglib动态代理，保证容器中的对象都是单例的。
三、Spring源码-注解说明
zcdlove的博客
05-03 1257
1.@Configuration   Indicates that a class declares one or more @Bean methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime, for example: @Configuration public class AppConfig {
Spring - 注解源码解析
你今天真好看呀
04-28 1802
文章目录Spring IOC注解解析一、组件注册的几种方式1、@Configuration注解2、@ComponentScan注解1、自动扫描组件2、指定扫描规则3、自定义FilterType指定过滤规则3、@Scope注解4、@Lazy注解5、@Import注解1、使用类名导入组件2、ImportSelector3.ImportBeanDefinitionRegistrar6、FactoryBe...
Spring源码-注解版
qq_50653148的博客
03-24 369
作为小白，学习Spring框架用了很久很久，而且还处于只会用的阶段。刚步入公司实习，深刻觉得框架源码的掌握非常重要。公司项目基于源码做了很多拓展，但是我连原生框架都没看明白，深感自己菜的离谱。Csdn上讲Spring源码的博客很混乱，找不到讲的很清晰的。所以今天斗胆尝试写一篇从头到尾的文章。我深知文章中有很多错误、不详细、讲的不好的地方，欢迎各位指错、私信讨论、写在评论区也可。
Spring Boot How-to：注解指南
这份文档来源于`spring-boot-1.5.12.RELEASE`版本的`spring-boot-docs`项目，具体路径为`src/main/asciidoc/howto.adoc`，这部分内容是`How-to`指导，旨在提供一些"如何做"的问题解答。 文档首先指出，虽然这不是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值