SpringIOC源码解析3(一步一步走战略)

最新推荐文章于 2020-06-02 13:19:38 发布
最新推荐文章于 2020-06-02 13:19:38 发布
阅读量98 收藏
点赞数
分类专栏： java开发记录 文章标签： springioc java 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44195647/article/details/103258706
版权
我们继续一步一步的研究pringIOC的步骤
我们还是要写一个创建容器的方法来进入这个流程中
public static void main(String[] args) {
        AnnotationConfigApplicationContext configApplicationContext=new 				AnnotationConfigApplicationContext("com.spring.bean");
  
    }
我们正式进入其逻辑

当点击上面的对象的时候 ,会出现下面的构造方法

public AnnotationConfigApplicationContext(String... basePackages) {
        //创建工厂组件
		this();
		//扫描配置
		scan(basePackages);
		//初始化容器
		refresh();
	}

看似简单的三个方法,实际却庞大无比

this()

实际上就是创建了下面两个方法执行需要的两个组件

public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}
scan(basePackages)
@Override
	public void scan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		this.scanner.scan(basePackages);
	}
Assert.notEmpty(basePackages, “At least one base package must be specified”);

仅仅是对传进来的参数作了一个是否为空的判断,如果为空则抛出异常以及其message

this.scanner.scan(basePackages);

点击这个scan方法,调用ClassPathBeanDefinitionScanner的一下方法

public int scan(String... basePackages) {
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

		doScan(basePackages);

		// Register annotation config processors, if necessary.
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
		}

		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
	}
  1. int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
    记录bean配置信息的个数
  2. doScan(basePackages); 调用本类(ClassPathBeanDefinitionScanner)中的doScan方法
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		//这里调用了一次Assert的非空判断抛异常的操作
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		//创建一个有序的非重复的 LinkedHashSet集合进行bean的保存 其中的对象是存储一个bean的各种属性(作用域,bean名称等属性)
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		//BeanDefinitionHolder 包含对象BeanDefinition ,BeanDefinition 属于BeanDefinitionHolder的一个属性
		for (String basePackage : basePackages) {
			//扫描对应包下的Components注解资源，把资源文件放到BeanDefinition配置里(需要了解)
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				//解析bean的scope作用域(需要了解)
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				//将所属作用域放入BeanDefinition
				candidate.setScope(scopeMetadata.getScopeName());
				//生成bean的名称
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				//判断candidate是否是AbstractBeanDefinition的一个实例
				if (candidate instanceof AbstractBeanDefinition) {
					//设置bean的一些默认属性，lazy,init,destory方法等(需要了解)
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				//通过解析类设置bean的一些属性，lazy,Primary,DependsOn等
				//判断candidate是否是AnnotatedBeanDefinition的一个实例
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				if (checkCandidate(beanName, candidate)) {
					//创建BeanDefinitionHolder对象保存提取bean的所有属性,并传入BeanDefinition(candidate)对象和beanName
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					//soope 是否需要设置代理
					//解决@Scope(value = WebApplicationContext.SCOPE_SESSION,proxyMode =ScopedProxyMode.INTERFACES)
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					//注册bean的配置信息到容器
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}
  • 调用Set candidates = findCandidateComponents(basePackage);目的是扫描带有@Compont注解的bean,实际上走的是点击find方法中的最下面的那个scanCandidateComponents(basePackage)方法.
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			//把扫描到的文件解析成Resource资源
			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 {
						//读取文件资源的各项属性
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						//是否包含component注解
						if (isCandidateComponent(metadataReader)) {
							//把候选资源转换为BeanDefinition
							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) {
						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;
	}
  • 最后调用registerBeanDefinition(definitionHolder, this.registry);
	protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
	}

最终调用BeanDefinitionReaderUtils类的registerBeanDefinition()方法进行配置注册工作
1、解析bean的Id 和别名

2、调用BeanDefinitionRegistry.registerBeanDefinition()方法把 bean的配置信息保存到beanDefinitionMap中

	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// 定义和设置bean的名称,同时根据名称把bean的配置信息保存到beanDefinitionMap中	
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// 设置bean的别名,同时建立别名和真正的名称建立关系保存到aliasMap中
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}
  1. refresh();容器初始化操作
    点击进入AbstractApplicationContext的refresh()方法
public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			//1、容器预处理工作
			prepareRefresh();

			// 2、获取bean工厂
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 3、设置工厂配置属性信息
			prepareBeanFactory(beanFactory);

			try {
				// 子类通过此方法在BeanFactory初始化完成之后做自定义的进一步设置
				postProcessBeanFactory(beanFactory);

				// 执行 BeanFactoryPostProcessor后置处理器逻辑
				invokeBeanFactoryPostProcessors(beanFactory);

				// 把实现了beanPostProcessor接口的类信息添加到容器
				registerBeanPostProcessors(beanFactory);

				// 初始化消息资源解析器
				initMessageSource();

				// 初始化事件监听器
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				//容器初始化扩展方法，交给子类实现
				onRefresh();

				// 获得注册监听器、派发容器初始化的事件
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				// 工厂信息初始化完成后，开始创建单例非懒加载的bean
				finishBeanFactoryInitialization(beanFactory);

				//进行一些初始化完成后的操作
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}
  • 3.1 : 容器预处理操作
prepareRefresh();

protected void prepareRefresh() {
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);

		if (logger.isInfoEnabled()) {
			logger.info("Refreshing " + this);
		}
		//初始化容器的属性值，交给子类容器自己处理
		initPropertySources();
		//环境变量验证
		getEnvironment().validateRequiredProperties();
		//保存容器早期事件
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}
  • 3.2 : 在refresh()里 调用obtainFreshBeanFactory（）获取bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();


	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		//设置容器状态信息
		refreshBeanFactory();
		//获得beanFactory （构造方法已创建）
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

protected final void refreshBeanFactory() throws BeansException {
		//先清空已存在Beanfactory
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			//创建beanFactory
			DefaultListableBeanFactory beanFactory = createBeanFactory();

			//
			beanFactory.setSerializationId(getId());
			//定义工厂创建bean的规则
			customizeBeanFactory(beanFactory);

			//加载配置文件、把配置文件解析为beandefinishion
			loadBeanDefinitions(beanFactory);

			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}
  • 3.3 : 在refresh()方法里调用prepareBeanFactory（）设置工厂的基础属性
prepareBeanFactory(beanFactory);

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		//3.1、类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
		//表达式解析器
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		//忽略自动装配接口
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		//3.4、注册自动装配接口
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		//添加后置处理器事件监听检测
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		//注册环境变量相关bean
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}
  • 3.4 : 在refresh()里 调用 invokeBeanFactoryPostProcessors()方法执行后置处理器。
此处执行了BeanDefinitionRegistryPostProcessor 和BeanFactoryPostProcessor后置处理器逻辑。
invokeBeanFactoryPostProcessors(beanFactory);

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {


public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
		Set<String> processedBeans = new HashSet<>();
		//判断是否为BeanDefinitionRegistry
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();
			//分别解析出并保存 BeanDefinitionRegistryPostProcessor 和BeanFactoryPostProcessor
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				//得到BeanDefinitionRegistryPostProcessor
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					//得到BeanFactoryPostProcessor
					regularPostProcessors.add(postProcessor);
				}
			}
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			//得到所有实现了BeanDefinitionRegistryPostProcessor的类
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			//第一步、首先解析实现了PriorityOrdered的类,这部分最先执行
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			//进行排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//注册到容器中
			registryProcessors.addAll(currentRegistryProcessors);
			//先执行实现了PriorityOrdered的类
			//	//这里只执行BeanDefinitionRegistryPostProcessors.postProcessBeanDefinitionRegistry()方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			//清空容器中的BeanDefinitionRegistryPostProcessors
			currentRegistryProcessors.clear();

			// 第二步, 解析实现了Ordered的类后置处理器
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// 第三步、执行其他BeanDefinitionRegistryPostProcessors后置处理器
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// 第四步、执行所有类的BeanDefinitionRegistryPostProcessors.postProcessBeanFactory()方法
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		//开始解析执行实现了BeanFactoryPostProcessor接口类的逻辑
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 逻辑同上
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// 逻辑同上
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// 逻辑同上
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		//执行实现了BeanFactoryPostProcessors接口的方法
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
		beanFactory.clearMetadataCache();
	}
  • 3.5 : 在refresh()里调用registerBeanPostProcessors（)注册beanPostProcessor后置处理器
把所有实现了beanPostProcessor接口的类，根据顺序分别保存到容器中
registerBeanPostProcessors(beanFactory);

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		//分别保存实现了PriorityOrdered，Ordered  接口的BeanPostProcessors
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			//得到实现了PriorityOrdered接口的BeanPostProcessor
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					//容器内部的BeanPostProcessor
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				//得到实现了Ordered接口的B没有指定顺序的
				orderedPostProcessorNames.add(ppName);
			}
			else {
				//什么排序接口都没实现的BeanPostProcessor
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		//先注入实现了PriorityOrdered接口的BeanPostProcessors
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 然后注入实现了Ordered接口的BeanPostProcessors
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 再注入没实现任何排序接口的BeanPostProcessors.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
		// 最后注入容器内部的BeanPostProcessors.
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}
未完待续
此男子淡漠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 源码分析（2）--SpringIoC源码分析
aidaowuqiong的博客
10-15 554
SpringIoC 初始化整体流程的跟踪，篇幅较长，耐心看完，肯定有惊喜。
Spring IOC源码分析（3）
看看写写，记录所学，权当笔记の
09-04 4137
1.IOC容器的依赖注入         Spring中，依赖注入是在用户第一次向IOC容器索要Bean时触发的（通过getBean方法）。        在BeanFactory中我们看到getBean（String…）函数，它的具体实现在AbstractBeanFac
Spring IOC 容器源码分析 - 获取单例 bean
GarfieldEr007的专栏
12-23 1158
1. 简介 为了写 Spring IOC 容器源码分析系列的文章，我特地写了一篇 Spring IOC 容器的导读文章。在导读一文中，我介绍了 Spring 的一些特性以及阅读 Spring 源码的一些建议。在做完必要的准备工作后，从本文开始，正式开始进入源码分析的阶段。 在本篇文章中，我将会详细分析BeanFactory的getBean(String)方法实现细节，getBean(Strin...
深入解析Spring IoC：源码与实践指南
最新发布
12-13
在深入解析Spring IoC的过程中，我们首先关注的是其核心组件——IoC（Inversion of Control，控制反转）机制。Spring框架通过IoC容器管理应用程序的组件，实现了依赖注入，使得对象之间的依赖关系由容器负责建立和...
深入解析Spring IoC源码：核心机制与实践应用
12-13
《深入解析Spring IoC源码：核心机制与实践应用》 Spring框架的IoC（Inversion of Control，控制反转）是其核心特性之一，它极大地简化了Java应用程序的开发。本文将深入剖析Spring IoC容器的源码，揭示其工作原理...
Spring IoC源码深度剖析开源架构源码2021.pdf
04-27
标题《Spring IoC源码深度剖析开源架构源码2021.pdf》和描述《Spring IoC源码深度剖析开源架构源码2021.pdf》表明该文档主要面向于分析Spring框架中控制反转（IoC）容器的核心源码，解析和理解其内部的工作机制及...
SpringIOC源码.rar
06-10
3、 使用反射的手段读取指定目录下的class信息，解析Class信息； 4、 对Class信息的注解做处理； 5、 以键值对的方式创建beanID，bean对象，并且放到容器中； 6、 使用的时候通过beanID获取Bean对象。
Spring源码解析.zip
07-31
本压缩包“Spring源码解析”提供了对Spring框架核心组件——IOC（Inversion of Control，控制反转）、AOP（Aspect Oriented Programming，面向切面编程）以及Transaction（事务管理）的源码分析，帮助开发者更全面地...
多态和策略模式
此男子淡漠
07-01 1941
今天我们继续来讲解一下有关于多态和策略模式 多态 说到多态,我们都知道这是java的特性(继承,封装,多态,抽象)之一,但是我们对他了解多少呢? 我们首先了解一下它的概念: 相同类型的变量，调用同一个方法时呈现出多种不同的行为特征，主要是通过继承来实现，将子类对象直接赋给父类引用变量，这样在编译时引用变量类型是父类类型，而运行时类型是子类类型，导致运行时调用该引用变量的方法总会表现子类方法，而调用...
对象的创建简述
此男子淡漠
05-26 1102
对象的创建 #### 对象的创建方式 使用new关键字创建对象 Java java = new Java(); 使用Class类的newInstance方法(反射机制) Java java = (Java)Class.forName("Java类全限定名").newInstance();　 　　 Java java = Java.class.newInstance(); 使用Constructor类的newInstance方法(反射机制) java.lang.relect.Constru
MVCC多版本控制
此男子淡漠
07-30 959
我们回顾一下之前所讲解的事务,那么mysql是如何解决事务的原子性和一致性呢?(加锁,保证事务执行时不被干扰,在一个原子单位内的操作，必须保证这个原子操作后的数据前后一致。) 首先我们要明确一个事情,MVVC是什么,是为了解决什么? 我们基本都清楚数据库的锁机制可以控制并发,为了保护安全对于读写操作一般都会加锁,就是读的时候不能写,写的时候不能读.这样虽然对于数据库的数据来说很安全,但是也从性能上...
索引原理
此男子淡漠
07-15 960
索引简述: 索引是一个排序的列表，在这个列表中存储着索引的值和包含这个值的数据所在行的物理地址，在数据十分庞大的时候，索引可以大大加快查询的速度，这是因为使用索引后可以不用扫描全表来定位某行的数据，而是先通过索引表找到该行数据对应的物理地址然后访问相应的数据。 我们可以用大白话理解一下: 假如我们一般习惯于使用模糊查询,那么如果在数据量千万级别甚至以上的基础下我们如果不进行优化,那么查询速度会大...
dubbo实际项目应用
此男子淡漠
10-22 553
dubbo实际应用 上一期,我们虽然搭建了dubbo项目,但是并没有利用其它的注册中心,我们直接使用的 N/A 本地地址. 但是实际上我们需要使用的是一个可以为我们提供一个消费者与生产者之间,管理这些服务并分配服务的一个中间件.因此我们引入了zookeeper 一丶配置注册中心 添加依赖 <dependency> <groupId&gt...
Mysql常用查询语句以及函数(一)
此男子淡漠
06-10 528
排名 首先列出一个例子: SELECT A.*,@rank :=@rank + 1 AS ranking FROM ( SELECT user_name, user_source FROM test ORDER BY source DESC ) A, (SELECT @rank := 0) B 其中 rank名称任意 重点是: (SELECT @rank := 0) B和 @rank :=@ra...
垃圾回收算法简述
此男子淡漠
06-02 508
JVM垃圾回收算法 圾回收内存布局,就不得不去了解一下其垃圾回收算法. 在了解算法之前,我们先想一下什么是垃圾? 顾名思义我们用不到了,它的存在对于我们来说是多余的,没用的. 那么在jvm中什么 对象是垃圾呢? 在java中是通过引用来和对象进行关联的，也就是说如果要操作对象，必须通过引用来进行。 那么如果一个对象不会再被引用,那么这个对象(垃圾)就需要被回收. 如何去判断一个对象不再被引用? 这里引入一种叫做"引用计数器"的算法,简单的就是一个对象被引用了,那么引用计数器就加1,反之就减1,当它的引用计
SpringMVC(视图解析器)
此男子淡漠
12-24 351
上一期我们模拟了前端控制器,接收访问,并解析请求连接,能直接定位到指定的controller中的方法中. 这次我们看一下视图解析器 SpringMVC用于处理视图最重要的两个接口是ViewResolver和View。ViewResolver的主要作用是把一个逻辑上的视图名称解析为一个真正的视图，SpringMVC中用于把View对象呈现给客户端的是View对象本身，而ViewResolver只是把...
zookeeper安装
此男子淡漠
09-24 286
去官网下载你想要下载某一版本的tar包 点击跳转官网下载 或者直接在linus中输入一下命令 wget https://archive.apache.org/dist/zookeeper/zookeeper-3.4.11/zookeeper-3.4.11.tar.gz 找一个代理或者找一个第三方网站下载也行,国外网站打开可能有点慢 上传解压 在这里你可以选择你喜欢的上传方式将你下载好的tar包上...
事务和锁
此男子淡漠
07-23 251
事务的特性 事务的ACID特性 A(Atomicity)原子性 事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。通常，与某个事务关联的操作具有共同的目标，并且是相互依赖的。如果系统只执行这些操作的一个子集，则可能会破坏事务的总体目标。原子性消除了系统处理操作子集的可能性。 C(Consistency)一致性 事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值