spring5.1.x源码解析之十三(spring自动注入)

最新推荐文章于 2021-09-07 20:35:38 发布
最新推荐文章于 2021-09-07 20:35:38 发布
阅读量216 收藏 3
点赞数
分类专栏： spring源码解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nuan_Feng/article/details/105847280
版权

文章目录

Demo

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="org.example.context" ></context:component-scan>

</beans>

package org.example.context;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

public class App {
    public static void main(String[] args) {
        ApplicationContext bf = new ClassPathXmlApplicationContext("context.xml");
        //BeanFactory bf = new XmlBeanFactory(new ClassPathResource("context.xml"));
        MyService autoTest = (MyService) bf.getBean("myService");
        autoTest.sayHello();
    }
}


package org.example.context;

import lombok.Data;
import org.springframework.stereotype.Repository;


@Repository
@Data
public class Dao {
    private String name="heh";
    private String age="15";

}


package org.example.context;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;



@Service
public class MyService {
    @Autowired
    private Dao dao;

    public void sayHello() {
        System.out.println(dao.toString());
    }
}

解析成beanDefinitions

public class ComponentScanBeanDefinitionParser implements BeanDefinitionParser {

	//扫描的基本包路径
	private static final String BASE_PACKAGE_ATTRIBUTE = "base-package";

	//对资源进行筛选的正则表达式，这边是个大的范畴，具体细分在include-filter与exclude-filter中进行 -->
	private static final String RESOURCE_PATTERN_ATTRIBUTE = "resource-pattern";

	// 是否使用默认的过滤器，默认值true
	private static final String USE_DEFAULT_FILTERS_ATTRIBUTE = "use-default-filters";

	//是否激活属性注入注解
	private static final String ANNOTATION_CONFIG_ATTRIBUTE = "annotation-config";

	// Bean的ID策略生成器
	private static final String NAME_GENERATOR_ATTRIBUTE = "name-generator";

	//scope解析器 ，与scoped-proxy只能同时配置一个.将@Scope(value="",proxyMode=ScopedProxyMode.NO,scopeName="")的配置解析成为一个ScopeMetadata对象,
	private static final String SCOPE_RESOLVER_ATTRIBUTE = "scope-resolver";

	//scope代理，与scope-resolver只能同时配置一个.scope代理，有三个值选项，no(默认值)，interfaces(接口代理)，targetClass（类代理）
	private static final String SCOPED_PROXY_ATTRIBUTE = "scoped-proxy";

	private static final String EXCLUDE_FILTER_ELEMENT = "exclude-filter";

	private static final String INCLUDE_FILTER_ELEMENT = "include-filter";

	private static final String FILTER_TYPE_ATTRIBUTE = "type";

	//用来告知哪些类需要注册成Spring Bean,使用type和expression属性一起协作来定义组件扫描策略。
	private static final String FILTER_EXPRESSION_ATTRIBUTE = "expression";}



	/*
	解析扫描包路径
	生成扫描器,对注解和xml属性设置
	扫描生成BeanDefinitionHolder
	注册
	 */
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		//获取扫描包路径base-package
		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
		//环境变量解析
		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
				//分隔
		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

		// Actually scan for bean definitions and register them.
		//生成扫描器,对注解和xml属性设置
		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
		//真正扫描在这儿
		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
		//注册
		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

		return null;
	}

	/*
	对xml配置属性设置
	 */
	protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
		boolean useDefaultFilters = true;
		//用默认过滤器使用默认的 Filter 进行包扫描，而默认的 Filter 对标有 @Service,@Controller和@Repository 的注解的类进行扫描，
		if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
			useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
		}

		// Delegate bean definition registration to scanner class.
		//内部有对java注解和spring注解支持
		ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
		//设置检测到bean的默认值
		scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
		//设置名称匹配模式
		scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());

		//过滤出特定的类
		if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
			scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
		}

		try {
			//设置默认名称构造器
			parseBeanNameGenerator(element, scanner);
		} catch (Exception ex) {
			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
		}

		try {
			parseScope(element, scanner);
		} catch (Exception ex) {
			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
		}

		parseTypeFilters(element, scanner, parserContext);

		return scanner;
	}

protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
		return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters,
				readerContext.getEnvironment(), readerContext.getResourceLoader());
	}

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

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		if (useDefaultFilters) {
			registerDefaultFilters();
		}
		setEnvironment(environment);
		setResourceLoader(resourceLoader);
	}

protected void registerDefaultFilters() {
		//这里有对所有的Service,@response,@Controller等注解的支持
		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
		//对JSR250 330支持
		try {
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
			logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
		}
		try {
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
			logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}


/*
	扫描包,生成BeanDefinition
	对注解bean的处理
	注册bean
	 */
	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) {
			//扫描包下basePackage路径下java文件
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				//解析scope
				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);
				}
				//如果是AnnotatedBeanDefinition类型的Bean
				if (candidate instanceof AnnotatedBeanDefinition) {
					// 检测常用注解，如primary,Lazy,DependsOn,Role等
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				//检测当前bean是否注册
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					//如果当前bean使用来生成代理的bean,进行下一步处理
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					//注册BeanDefinition,以及别名
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

protected void registerComponents(
			XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {

		Object source = readerContext.extractSource(element);
		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);

		for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
			compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
		}

		// Register annotation config processors, if necessary.
		boolean annotationConfig = true;
		if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
			annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
		}

		// Register annotation config processors, if necessary.
		if (annotationConfig) {
		//如果配置了includeAnnotationConfig,则注册对应注解的处理器以保证注解功能的正常使用
			Set<BeanDefinitionHolder> processorDefinitions =
					AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
			for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
				compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
			}
		}

		readerContext.fireComponentRegistered(compositeDef);
	}

	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));
		}

		//@Autowired自动装配注解器处理
		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			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;
	}

加载对象

注意XmlBeanFactory解析的时候不会注入@Autowired标记对象,访问才加载对象.
因为虽然注册@Autowired解析的处理器,但没有加载,所以无法解析属性,而且没有对非懒加载对象的处理.
org.springframework.context.support.AbstractApplicationContext#refresh

	public void refresh() throws BeansException, IllegalStateException {
	...
				//激活各种BeanFactory处理器
				//AutowiredAnnotationBeanPostProcessor在这儿激活的
	invokeBeanFactoryPostProcessors(beanFactory);
		
		//初始化剩下的非延迟初始化单实例,一般在这里初始化注解的对象,以及处理@Autowired
				finishBeanFactoryInitialization(beanFactory);
...
}

注入@Auto

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata

缓存InjectionMetadata

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);
					this.injectionMetadataCache.put(cacheKey, metadata);//缓存注解对象
				}
			}
		}
		return metadata;
	}

	private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
		Class<?> targetClass = clazz;

		do {
			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

			ReflectionUtils.doWithLocalFields(targetClass, field -> {
				//获取Autowired对象
				AnnotationAttributes ann = findAutowiredAnnotation(field);
				if (ann != null) {
					if (Modifier.isStatic(field.getModifiers())) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation is not supported on static fields: " + field);
						}
						return;
					}
					boolean required = determineRequiredStatus(ann);
					currElements.add(new AutowiredFieldElement(field, required));
				}
			});

			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
					return;
				}
				AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
					if (Modifier.isStatic(method.getModifiers())) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation is not supported on static methods: " + method);
						}
						return;
					}
					if (method.getParameterCount() == 0) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation should only be used on methods with parameters: " +
									method);
						}
					}
					boolean required = determineRequiredStatus(ann);
					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
					currElements.add(new AutowiredMethodElement(method, required, pd));
				}
			});

			elements.addAll(0, currElements);
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);

		return new InjectionMetadata(clazz, elements);
	}

赋值

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	...
	PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
	...
	}

@Override
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	...
	//对属性获取完毕前对属性再次处理
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					//对所有需要依赖检查的属性进行后处理,其中包括对每个属性的校验RequiredAnnotationBeanPostProcessor
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
}
...

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessProperties

@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
		try {
			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;
	}

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);
					this.injectionMetadataCache.put(cacheKey, metadata);//缓存注解对象
				}
			}
		}
		return metadata;
	}

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) {
				if (logger.isTraceEnabled()) {
					logger.trace("Processing injected element of bean '" + beanName + "': " + element);
				}
				element.inject(target, beanName, pvs);
			}
		}
	}

@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 = 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);//转换@Auto为对象
				}
				catch (BeansException ex) {
					throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
				}
				synchronized (this) {
					if (!this.cached) {
						if (value != null || this.required) {
							this.cachedFieldValue = desc;
							registerDependentBeans(beanName, autowiredBeanNames);
							if (autowiredBeanNames.size() == 1) {
								String autowiredBeanName = autowiredBeanNames.iterator().next();
								if (beanFactory.containsBean(autowiredBeanName) &&
										beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
									this.cachedFieldValue = new ShortcutDependencyDescriptor(
											desc, autowiredBeanName, field.getType());
								}
							}
						}
						else {
							this.cachedFieldValue = null;
						}
						this.cached = true;
					}
				}
			}
			if (value != null) {//设置@Auto对象
				ReflectionUtils.makeAccessible(field);
				field.set(bean, value);
			}
		}
	}
Nuan_Feng
关注
专栏目录
Spring Boot自动注入的原理分析
08-25
主要给大家分析介绍了关于Spring Boot自动注入的原理，文中通过示例代码介绍的非常详细，对大家的学习或者使用Spring Boot自具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
spring5.1.x版本源码解析
xuchuanliang11的博客
08-30 273
本次源码解析主要包含以下几个部分： 1.AnnotationConfigApplicationContext中根据@ComponentScan扫描解析包下的类，并封装成为BeanDefinition； 2.AnnotationConfigApplicationContext中配置类常见注解如@Import、@Bean、@Component、@Service、@ComponentScan、@ImportResource等注解的解析流程以及细节； 3.标记有@Configuration注解以及无该注解的配
官方原版源码spring-framework-5.1.13.RELEASE.zip
01-15
官方原版源码spring-framework-5.1.13.RELEASE.zip
第一章 基于Spring Framework 5.1.3 探索Spring的启动流程
LJHSkyWalker的博客
02-23 862
----开篇言：由于自己才疏学浅，加上入行两年多的时间了，如果还停留在if else的阶段，不去深入了解一款框架，不去深入学习一些源码，不去探索一些设计思想，那么自己的核心竞争力就约等于0 。打算利用这两天，深度分析一下Spring Framework框架启动机制与IOC、AOP的底层设计思想，还有著名的Dubbo框架的信息流转方式与底层netty的交互方式，还有Reactor的一些设计思路。 ...
spring-beans-5.0.0.RELEASE.jar
10-13
注意：本资源用于学习而非盈利，第三方若认为版权受侵可联系官方删帖
spring-framwork-5.1.x:建造好的spring5.1.x源码阅读环境
03-23
Spring框架是Java开发中最常用的轻量级框架之一，它的5.1.x版本引入了许多改进和新特性，旨在提升性能和开发者体验。这个压缩包“spring-framework-5.1.x”提供了一个已经配置好的环境，方便开发者对Spring源码进行...
spring-framework-5.1.x.zip
03-17
《Spring框架5.1.x深度解析》 Spring框架作为Java领域中最流行的开源框架之一，以其模块化、松耦合的设计理念赢得了广大开发者的青睐。5.1.x版本是Spring发展中的一个重要里程碑，它在前一版本的基础上进行了诸多...
spring-framework-5.1.x-源碼解析详细注解
09-22
《Spring Framework 5.1.x 源码解析详细注解》 Spring Framework作为Java开发中的核心框架，其设计理念和实现机制对理解企业级应用的构建至关重要。本资源提供了Spring 5.1.x版本的源码详细注解，旨在帮助开发者...
spring-5.1.x_ch(含文档).zip
12-05
《Spring 5.1.x 源码深度解析》 Spring 框架作为 Java 开发中的核心组件，它的设计理念和实现方式对于提升开发者技能、理解企业级应用开发有着重要作用。Spring 5.1.x 版本是其发展历程中的一个重要里程碑，引入了...
spring-beans-5.0.2.RELEASE.jar官网下载
01-22
spring-beans-5.0.2.RELEASE.jar官网下载，值得信任，需要的拿走
spring-beans-5.0.4.RELEASE
04-02
spring-beans-5.0.4.RELEASE.......................................................................
spring-beans-3.2.13.RELEASE.jar
02-23
spring mvc和ssm整合资料
Spring5.1源码解析（一）源码编译导入idea
hzau_itdog的博客
12-27 844
一、编译前的准备 介绍下环境 jdk使用 jdk-11.0.5 idea使用2019.2.4版本 gradle使用gradle-5.6.3 说明idea2019.3有bug，会造成源码构建失败 1、下载gradle配置环境变量 gradle下载地址gradle官网（https://gradle.org/releases/） 在系统高级配置里配置环境变量 我的gradl...
Spring Boot 核心编程思想-第二部分-读书笔记
阿飞云漫步
08-14 888
怕什么真理无穷进一步有近一步的欢喜说明本文是Spring Boot核心编程思想记录的笔记，书籍地址：Spring Boot编程思想（核心篇）：这篇文档会记录这本我的一些读书的思考，内容可能...
spring5.1.x源码解析之十三(常见问题)
Nuan_Feng的博客
06-29 360
spring如何实现标签功能扩展的? spring在解析doc的时候,会创建一个ReaderContext对象 ReaderContext对象创建的时候,会创建NamespaceHandlerResolver对象 在进行对象解析的时候,会分别解析默认命名空间和自定义的解析,也就是beans标签和非beans标签的解析 /* 获取所有已经配置的handler映射,读取配置文件 根据命名空间找到对应的信息 当是类的时候说明,已经做过解析直接缓存读取,直接返回 没有做过解析,返回类路径 判
Spring5 @Autowired
weixin_34101784的博客
03-20 264
为什么80%的码农都做不了架构师？>>> ...
Spring5.x源码分析 | 从踩坑到放弃之环境搭建
Eshare分享
08-16 8929
Spring5.x源码分析——从踩坑到放弃之环境搭建 前言 自从Spring发行4.x后，很久没去好好看过Spring源码了，加上最近半年工作都是偏管理和参与设计为主，在技术细节上或多或少有点疏忽，最近心血来潮想重新下Spring源码，对以往Spring知识点做下回顾，但是在构建环境的过程中出现各种问题，一个个坑修复后，最终还是成功把单测运行成功，没有报编译错误或者其他异常，总结了以下一些...
BeanUtils.copyProperties为嘛Copy不了内部类？
Nuan_Feng的博客
09-07 1283
@TOC 今天内部类copy失败，但是封装List的却成功了。 查看源码 isAssignableFrom：rhsType表示是否是lhsType子类或子接口。 isPrimitive：表示是否是基类，也就是不是内部类。 这里内部类会失败，主要是因为这二个条件判断失败。但是List包装的成功，是因为编译后泛型擦除，导致实际比较的是ArrayList类，所以这里直接返回true。 ...
跟我学Spring3：IoC与DI深度解析
主要涵盖了Spring的核心特性，包括IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入），以及AOP（Aspect-Oriented Programming，面向切面编程）和Spring表达式语言（Spring Expression ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值