atCarl
atCarl

Spring之配置类源码深度解析

这篇文章是继《Spring之启动过程源码解析之后》，对Spring启动过程中用到的几个重要的方法进行详细的解读

目录

一、invokeBeanFactoryPostProcessors()，执行BeanFactoryPostProcessor

1. 方法说明

2. invokeBeanFactoryPostProcessors()内部执行流程

二、registerBeanPostProcessors(),向BeanFactory中注册BeanPostProcessor

1.方法说明

2. registerBeanPostProcessors()内部执行流程

三、postProcessBeanDefinitionRegistry()解析

1. 方法总览

2. 处理流程

四、关于@Configuration注解

1. 生成代理类

2. 代理类的作用

3. 总结

一、invokeBeanFactoryPostProcessors()，执行BeanFactoryPostProcessor

1. 方法说明

在Spring启动过程中，当执行到invokeBeanFactoryPostProcessors()这个方法的时候，就意味着要执行BeanFactoryPostProcessor了，此时在BeanFactory中会存在一个BeanFactoryPostProcessor： ConfigurationClassPostProcessor，它也是一个BeanDefinitionRegistryPostProcessor；

2. invokeBeanFactoryPostProcessors()内部执行流程

2.1. 获取BeanFactoryPostProcessors，并且执行通过ApplicationContext添加进来的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法，注意：这里获取到的是通过ApplicationContext的addBeanFactoryPostProcessor()添加的BeanFactoryPostProcessor，我们自己定义的BeanFactoryPostProcessor如果没有像这样设置,在这里是获取不到的，因为Spring也得通过扫描才能发现；

2.2. 从BeanFactory中找到类型为BeanDefinitionRegistryPostProcessor的beanName， 匹配实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor，这里匹配到的是ConfigurationClassPostProcessor，同时会调用BeanFactory的getBean方法，将ConfigurationClassPostProcessor的对象创建出来，并执行它的postProcessBeanDefinitionRegistry()方法，在这一步会得到BeanDefinition；

注意：在ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()方法会进行扫描，得到BeanDefinition并注册，下面会有关于这个方法的详细分析；

2.3. 从BeanFactory中找到类型为BeanDefinitionRegistryPostProcessor的beanName，匹配实现了Ordered接口的BeanDefinitionRegistryPostProcessor，执行BeanFactory中实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法；

说明：因为在上面那一步中，Spring就会进行扫描，所以这里从BeanFactory中找到类型为BeanDefinitionRegistryPostProcessor的beanName也包括我们自定义的；

2.4. 执行那些没有实现了PriorityOrdered或Ordered接口的普通BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法；

2.5. 执行上面所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法；

2.6. 执行通过ApplicationContext添加进来的BeanFactoryPostProcessor的 postProcessBeanFactory()方法；

2.7. 执行BeanFactory中实现了PriorityOrdered接口的BeanFactoryPostProcessor的 postProcessBeanFactory()方法；

2.8. 执行BeanFactory中实现了Ordered接口的BeanFactoryPostProcessor的 postProcessBeanFactory()方法；

2.9. 执行BeanFactory中其他的BeanFactoryPostProcessor的postProcessBeanFactory()方法；

二、registerBeanPostProcessors(),向BeanFactory中注册BeanPostProcessor

1.方法说明

因为上面的步骤完成了扫描，这个过程中开发者可能自己定义了一些BeanPostProcessor，在这一步就会把BeanFactory中所有的BeanPostProcessor找出来并实例化得到一个对象，并添加到BeanFactory中去(属性beanPostProcessors)，最后再重新添加一个ApplicationListenerDetector对象(之前其实就添加过了，这里是为了把ApplicationListenerDetector移动到最后)；

2. registerBeanPostProcessors()内部执行流程

2.1. 获取BeanFactory中所有实现了BeanPostProcessor接口的beanName;

2.2. 声明不同的集合并初始化，以便后面对BeanPostProcessor进行分类；

2.3. 遍历2.1 获取的beanName集合，对BeanPostProcessor进行分类：

 ① 首先根据beanName，匹配实现了PriorityOrdered接口的BeanPostProcessor， 并得到其实例对象，如果这个实例对象同时实现了MergedBeanDefinitionPostProcessor，还需要将它单独记录；

 ② 否则，匹配实现了Ordered接口的BeanPostProcessor，但是这里并没有去beanFactory中获取实例对象，而是将符合条件的beanName存到了一个集合中；

 ③ 如果不满足①②，则将没有实现任何排序接口的beanName也存到了一个集合中；

2.4. 对实现了PriorityOrdered接口的BeanPostProcessor实例进行排序，然后注册到beanFactory中(会存到beanPostProcessors这个List中)；

2.5. 遍历实现了Ordered接口的BeanPostProcessor的beanName ，获取其实例，并添加到相应的集合中，如果实现了MergedBeanDefinitionPostProcessor则存放到相应的集合中，然后排序注册到beanFactory中；

2.6. 遍历剩余实现了BeanPostProcessor接口beanName ，获取其实例添加到相应的集合中,如果实现了MergedBeanDefinitionPostProcessor则存放到相应的集合中 , 然后注册到beanFactory中；

2.7. 将前面收集到的实现了MergedBeanDefinitionPostProcessor的BeanPostProcessor实例进行排序，重新注册到beanFactory中；

2.8. 将ApplicationListenerDetector注册到beanFactory中，在prepareBeanFactory(beanFactory)方法中，Spring其实就已经将ApplicationListenerDetector注册到了beanFactory中，这里重新注册，目的是将它放到最后；

说明：Spring将MergedBeanDefinitionPostProcessor排在最后，是因为Spring把这些MergedBeanDefinitionPostProcessor当做是Spring内部的BeanPostProcessors，这里可能存在一个用户优先的原则；

/**
 * 向BeanFactory中注册BeanPostProcessor
 */
public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		/**
		 * 获取BeanFactory中所有实现了BeanPostProcessor接口的beanName
		 * 不包括prepareBeanFactory(beanFactory)这一步添加到beanFactory中的三个BeanPostProcessor实例对象
		 * 这三个实例对象在Spring进行扫描之前就已经添加到了beanPostProcessors这个list中
		 */
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
	    //beanProcessorTargetCount表示BeanFactory中所有的BeanPostProcessor数量,+1表示BeanPostProcessorChecker
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		/**
		 * 存放实现了PriorityOrdered接口的BeanPostProcessor实例
		 */
		List priorityOrderedPostProcessors = new ArrayList<>();
		/**
		 * 存放实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor实例
		 * 主要是Spring内部的BeanPostProcessor,例如：AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor
		 */
		List internalPostProcessors = new ArrayList<>();
		/**
		 * 存放实现了Ordered接口的BeanPostProcessor实例
		 */
		List orderedPostProcessorNames = new ArrayList<>();
		/**
		 * 存放剩余的BeanPostProcessor实例
		 */
		List nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			/**
			 * 实现了PriorityOrdered接口的话就获取实例存放到集合中
			 * 如果实例实现了MergedBeanDefinitionPostProcessor中存放到相应的集合中
			 */
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			/**
			 * 实现了Ordered接口的话就将beanName存放到相应集合中
			 */
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			/**
			 * 没有实现任何排序接口的话就将beanName存放到相应集合中
			 */
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		/**
		 * 升序排序
		 * 对实现了PriorityOrdered接口的BeanPostProcessor实例进行排序,然后注册到容器中
		 */
  		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		/**
		 * 遍历实现了Ordered接口的BeanPostProcessor的beanName
		 * 获取其实例添加到相应的集合中，如果实现了MergedBeanDefinitionPostProcessor则存放到相应的集合中
		 * 然后排序注册到容器中
		 */
		List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		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);

		// Now, register all regular BeanPostProcessors.
		/**
		 * 遍历剩余实现了BeanPostProcessor接口beanName
		 * 获取其实例添加到相应的集合中,如果实现了MergedBeanDefinitionPostProcessor则存放到相应的集合中
		 * 然后注册到容器中
		 */
		List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		/**
		 *  MergedBeanDefinitionPostProcessor排在最后
		 * 最后排序实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor
		 * 然后注册到容器中
		 */
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		// ApplicationListenerDetector放在所有BeanPostProcessor之后，注意ApplicationListenerDetector的equals()方法实现
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

三、postProcessBeanDefinitionRegistry()解析

1. 方法总览

在执行invokeBeanFactoryPostProcessors()方法的过程中，会获取Spring内部提供的ConfigurationClassPostProcessor，执行其中的postProcessBeanDefinitionRegistry()以及postProcessBeanFactory()方法；

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);

		// 解析配置类
		processConfigBeanDefinitions(registry);
}

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		List configCandidates = new ArrayList<>();
		String[] candidateNames = registry.getBeanDefinitionNames();

		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			// 找配置类,什么是配置类？
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				//BeanDefinitionHolder顾明思义就是对BeanDefinition的持有,作用是根据名称或者别名持有beanDefination,承载了name和BeanDefination的映射信息
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

		// Return immediately if no @Configuration classes were found
		if (configCandidates.isEmpty()) {
			return;
		}

		// Sort by previously determined @Order value, if applicable
		// 通过@Order可以排序，升序排序，order越小越靠前
		configCandidates.sort((bd1, bd2) -> {
			int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
			int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
			return Integer.compare(i1, i2);
		});

		// Detect any custom bean name generation strategy supplied through the enclosing application context
		SingletonBeanRegistry sbr = null;
		if (registry instanceof SingletonBeanRegistry) {
			sbr = (SingletonBeanRegistry) registry;
			if (!this.localBeanNameGeneratorSet) {
				// BeanNameGenerator,bean名字生成器
				// 可以预先往单例池中添加一个beanName为CONFIGURATION_BEAN_NAME_GENERATOR的BeanNameGenerator类型的bean
				// 用来作为bean名字生成器,生成扫描得到的Bean和import导入进来的Bean的beanName
				BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
						AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
				if (generator != null) {
					this.componentScanBeanNameGenerator = generator;
					this.importBeanNameGenerator = generator;
				}
			}
		}

		if (this.environment == null) {
			this.environment = new StandardEnvironment();
		}

		//上面已经找到配置类了,接下来就是去解析配置类,所以这里会构造一个配置类的解析器
		// Parse each @Configuration class
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);

		Set candidates = new LinkedHashSet<>(configCandidates);
		Set alreadyParsed = new HashSet<>(configCandidates.size());

		// 递归解析配置类,有可能通过解析一个配置类,得到了其他的配置类,比如扫描和Import
		do {
			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");

			// 解析配置类,会把每个BeanDefinitionHolder首先封装为ConfigurationClass
			// 在这个过程中会进行扫描、导入等步骤,从而会找到其他的ConfigurationClass
			// 解析配置类的结果是什么？
			parser.parse(candidates);  // AppConfig.class--->BeanDefinition
			parser.validate();

			//由于解析配置类有可能会得到其它配置类,这里获取到的是目前为止所有的配置类,而且这些配置类是被解析过了的,但并不表示整个Spring容器只有这些配置类
			//例如解析AppConfig.class后,会得到其它的一些配置类
			// configClasses相当于就是解析之后的结果
			Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
			configClasses.removeAll(alreadyParsed);

			// Read the model and create bean definitions based on its content
			if (this.reader == null) {
				this.reader = new ConfigurationClassBeanDefinitionReader(
						registry, this.sourceExtractor, this.resourceLoader, this.environment,
						this.importBeanNameGenerator, parser.getImportRegistry());
			}
			// 把所有的ConfigurationClass加载成BeanDefinition,通常情况下一个配置类会对应一个BeanDefinition,不过也有可能一个配置类对应多个BeanDefinition
			// 比如一个配置类中有多个加了@Bean注解的方法,会对应多个BeanDefination,一个配置类配置了@ImportResource,基本也会得到多个BeanDefintion
			this.reader.loadBeanDefinitions(configClasses);

			alreadyParsed.addAll(configClasses);
			processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

			// candidates中存的是BeanDefinition，configClasses中存的是ConfigurationClass
			candidates.clear();

			// 如果发现BeanDefinition增加了，则有可能增加了配置类
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				Set alreadyParsedClasses = new HashSet<>();
				for (ConfigurationClass configurationClass : alreadyParsed) {
					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
				}
				for (String candidateName : newCandidateNames) {
					if (!oldCandidateNames.contains(candidateName)) {
						BeanDefinition bd = registry.getBeanDefinition(candidateName);

						// 检查多出来的BeanDefinition是不是配置类，需不需要解析
						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
								!alreadyParsedClasses.contains(bd.getBeanClassName())) {
							candidates.add(new BeanDefinitionHolder(bd, candidateName));
						}
					}
				}
				candidateNames = newCandidateNames;
			}
		}
		while (!candidates.isEmpty());

		// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
		if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
			sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
		}

		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
			// Clear cache in externally provided MetadataReaderFactory; this is a no-op
			// for a shared cache since it'll be cleared by the ApplicationContext.
			((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
		}
}

2. 处理流程

1. 从BeanFactory中，获取已经添加到Bean工厂中的BeanDefination

这里获取到的通常是在容器启动过程中Spring添加到BeanFactory中的BeanDefination，以及通过ApplicationContext的register()方法注册的类对应的BeanDefination;

Spring之配置类源码深度解析_第1张图片

2. 找配置类

2.1. 获取BeanDefination对应的类上面的注解的元数据，AnnotationMetadata表示某个类的注解信息；

2.2. 判断这个类上面有没有加@Configuration注解，进一步确定当前的类是不是配置类；

那什么样的类才算是配置类呢？这是才确定配置类的关键，符号以下条件的都会被判断为是配置类：

 ① 加了@Configuration注解，并且proxyBeanMethods不为false(为true或为null)时，就是full配置类；

 ② 加了@Configuration注解，并且proxyBeanMethods为false时，是lite配置类；

 ③ 没有加@Configuration注解，但是只要存在@Component、@ComponentScan、@Import、     @ImportResource四个中的一个，就是lite配置类；

 ④没有加@Configuration注解，只要存在加了@Bean注解的方法，就是lite配置类；

3.解析配置类

配置类思维脑图：ProcessOn Mindmap

3.1. 首先会把类的元信息和beanName封装为ConfigurationClass；

protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
	// 把类的元信息和beanName封装为ConfigurationClass
	processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}

3.2. 处理配置类，配置类解析过后，最终会将解析过的配置类放到configurationClasses这个map中；

protected void processConfigurationClass(ConfigurationClass configClass, Predicate filter) throws IOException {
	// 条件注解，就是看有没有类上是否有@Conditional注解,如果有，则进行条件匹配
	if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
	}
	ConfigurationClass existingClass = this.configurationClasses.get(configClass);
	if (existingClass != null) {
		if (configClass.isImported()) {
			// OrderService导入了AccountService,UserService也导入了AccountService,就会符合这个条件
			if (existingClass.isImported()) {
					existingClass.mergeImportedBy(configClass);
			}
			// Otherwise ignore new imported config class; existing non-imported class overrides it.
			return;
		}
		else {
			// Explicit bean definition found, probably replacing an import.
			// Let's remove the old one and go with the new one.
			this.configurationClasses.remove(configClass);
			this.knownSuperclasses.values().removeIf(configClass::equals);
		}
	}

	// Recursively process the configuration class and its superclass hierarchy.(递归处理配置类及其超类层次结构)
	SourceClass sourceClass = asSourceClass(configClass, filter);
	do {
		//有可能配置类还有父类,所以这里会有一个循环处理
		sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
	}
	while (sourceClass != null);

	// ConfigurationClass重写了equals方法，只要两个ConfigurationClass对应的className相等就可以
	this.configurationClasses.put(configClass, configClass);
}

3.3 如果配置类上有@Component注解，就要进一步判断加了@Component注解的配置类，有没有内部类，如果有，则判断内部类是不是配置类，如果是，就要解析内部类；

/**
 * 这样配置最终也会被Spring解析为配置类
 */
@Component
public class AppConfig implements AppInterface {


  // 内部类
  class  User{

 	 @Bean
 	 public  UserService userService(){
 	 	return new UserService();
	 }


  }

}

3.4. 如果配置类上加了@PropertySource注解，读取注解中指定的配置文件，将文件中的内容解析出来，放到environment中，例如@PropertySource("spring.properties")；

3.5. 如果配置类上加了@ComponentScan注解，Spring就会进行扫描，得到的BeanDefinition会注册到Spring容器中，并且会检查扫描出来的BeanDefinition是不是配置类并进行解析;

说明：从定义来看，@Configuration 注解本质上还是@Component，因此， 或者 @ComponentScan都能处理@Configuration注解的类；

3.6. 如果配置类上加了@Import()注解，解析注解中导入的类，那就要分情况了：

① 如果import的类实现了ImportSelector接口，将这个类实例化出来，又会分为两种情况：

 如果这个实例是DeferredImportSelector类型的，表示推迟的ImportSelector，它会在当前这一批配置类都解析完了之后执行；

public void parse(Set configCandidates) {
	for (BeanDefinitionHolder holder : configCandidates) {
		BeanDefinition bd = holder.getBeanDefinition();
		try {
			// 解析BeanDefinition所对应的类
			if (bd instanceof AnnotatedBeanDefinition) {
				parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
			}
			else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
				parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
			}
			else {
				parse(bd.getBeanClassName(), holder.getBeanName());
			}
		}
		catch (BeanDefinitionStoreException ex) {
				throw ex;
		}
		catch (Throwable ex) {
			throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
		}
	}

	// 处理deferredImportSelectors,表示当前所有配置类解析完了之后才执行
	// deferredImportSelector表示推迟的ImportSelector，正常的ImportSelector是在解析配置类的过程中执行的
	this.deferredImportSelectorHandler.process();
}

 如果这个实例不是DeferredImportSelector类型的，就会执行selectImports()方法，处理它返回的   类，这些返回的类会被当认为是导入进来的类，进而继续调用processImports()方法；

② 如果import的类实现了ImportBeanDefinitionRegistrar接口，将这个类实例化出来，然后将实例作为属性添加到configClass里面；

③ 如果导入的类是普通类，那就把它当做配置类来解析；

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
		Collection importCandidates, Predicate exclusionFilter,
		boolean checkForCircularImports) {

	if (importCandidates.isEmpty()) {
		return;
	}

	if (checkForCircularImports && isChainedImportOnStack(configClass)) {
		this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
	}
	else {
		this.importStack.push(configClass);
		try {
			for (SourceClass candidate : importCandidates) {
				// 如果import的类实现了ImportSelector接口
				if (candidate.isAssignable(ImportSelector.class)) {
					// Candidate class is an ImportSelector -> delegate to it to determine imports
					Class candidateClass = candidate.loadClass();
					//将这个类实例化出来
					ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
								this.environment, this.resourceLoader, this.registry);
					Predicate selectorFilter = selector.getExclusionFilter();
					if (selectorFilter != null) {
						exclusionFilter = exclusionFilter.or(selectorFilter);
					}
					// 如果import的是DeferredImportSelector,表示推迟导入
					if (selector instanceof DeferredImportSelector) {
						this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
					} else {
						// 如果import的是普通的ImportSelector
						String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
						// 继续处理selectImports()所返回的类,这些返回的类被认为是导入进来的类,
						Collection importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
						processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
					}
				}
				// 如果import的类实现了ImportBeanDefinitionRegistrar接口
				else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
					// Candidate class is an ImportBeanDefinitionRegistrar ->
					// delegate to it to register additional bean definitions
					Class candidateClass = candidate.loadClass();
					//将这个类实例化出来
					ImportBeanDefinitionRegistrar registrar =
							ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
									this.environment, this.resourceLoader, this.registry);
					configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
				}
				// 如果import的类就是普通的类,就把import进来的类当做配置类
				else {
					// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
					// process it as an @Configuration class
					this.importStack.registerImport(
							currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
					// 注意，在asConfigClass方法中,不仅会将candidate生成一个ConfigurationClass,还会记录一下candidate是被哪个类导入的importedBy
					processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
				}
			}
		}
		catch (BeanDefinitionStoreException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanDefinitionStoreException(
					"Failed to process import candidates for configuration class [" +
					configClass.getMetadata().getClassName() + "]", ex);
		}
		finally {
			this.importStack.pop();
		}
	}
}

3.7. 如果配置类上加了ImportResource()注解，则获取注解中资源，将资源加入到当前配置类的属性中，此处仅仅是把注解内容解析出来，然后作为属性添加到configClass里面去，还并不是它真正的执行时机；

一个通用的结论：

@PropertySource()用于导入.properties属性配置文件；

@ImportResource()用于导入.xml的Bean信息的配置文件；

3.8. 将配置类中加了@Bean注解的方法找到并记录，但这里并没有真正处理@Bean；

3.9. 解析配置类所实现的接口中有没有default的方法上是加了@Bean的,但并没有真正处理@Bean；

3.10. 如果当前配置类还有父类，将父类返回继续处理父类；

@Nullable
protected final SourceClass doProcessConfigurationClass(
		ConfigurationClass configClass, SourceClass sourceClass, Predicate filter)
		throws IOException {

	if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
		// Recursively process any member (nested) classes first
		// 处理内部类
		// 在解析一个配置类时,如果类上有@Component,则会判断内部类是不是lite配置类并进行解析,并且会记录为被导入的
		processMemberClasses(configClass, sourceClass, filter);
	}

	// Process any @PropertySource annotations(处理@PropertySource注解)
	//如果配置类上加了@PropertySource,读取@PropertySource("spring.properties")中指定的配置文件,将文件中的内容解析出来,放到environment中
	for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
			sourceClass.getMetadata(), PropertySources.class,
			org.springframework.context.annotation.PropertySource.class)) {
		if (this.environment instanceof ConfigurableEnvironment) {
			processPropertySource(propertySource);
		}
		else {
			logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
					"]. Reason: Environment must implement ConfigurableEnvironment");
		}
	}

	// Process any @ComponentScan annotations(处理@ComponentScan注解)
	// 会进行扫描,得到的BeanDefinition会注册到Spring容器中,并且会检查是不是配置类并进行解析
	Set componentScans = AnnotationConfigUtils.attributesForRepeatable(
			sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
	if (!componentScans.isEmpty() &&
			!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
		for (AnnotationAttributes componentScan : componentScans) {
			// The config class is annotated with @ComponentScan -> perform the scan immediately
			// 这里就会进行扫描,得到的BeanDefinition会注册到Spring容器中
			Set scannedBeanDefinitions =
					this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
			// Check the set of scanned definitions for any further config classes and parse recursively if needed
			for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
				BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
				if (bdCand == null) {
					bdCand = holder.getBeanDefinition();
				}
				// 检查扫描出来的BeanDefinition是不是配置类（full和lite）
				if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
					parse(bdCand.getBeanClassName(), holder.getBeanName());
				}
			}
		}
	}

	// Process any @Import annotations(处理@Import注解)
	// getImports(sourceClass)会拿到@Import导入的类
	// 如果导入的是普通类,那么会直接把它当做配置类来解析
	// 如果导入的是普通ImportSelector，那么会将返回的类再次调用processImports()
	// 如果导入的是特殊ImportSelector，DeferredImportSelector，那么暂时不会处理，会在解析完所有当前这轮配置类后进行导入，将返回的类再次调用processImports()
	// 如果导入的是ImportBeanDefinitionRegistrar，那么暂时不会处理，会在解析完所有当前这轮配置类后，将配置类解析成为BeanDefinition之后进行调用
	processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

	// Process any @ImportResource annotations
	//获取注解中资源
	AnnotationAttributes importResource =
			AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
	if (importResource != null) {
		String[] resources = importResource.getStringArray("locations");
		Class readerClass = importResource.getClass("reader");
		for (String resource : resources) {
			// 显然它还支持${}这种方式去环境变量里取值的,比如spring-beans-${profie}.xml等
			String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
			//将资源加入到当前配置类的属性中,此处仅仅是把注解解析出来,然后作为属性添加到configClass里面去,还并不是它真正的执行时机
			configClass.addImportedResource(resolvedResource, readerClass);
		}
	}

	// Process individual @Bean methods
	// 将配置类中加了@Bean注解的方法找到并记录,但并没有真正处理@Bean,即并没有真正地去解析加了@Bean注解的方法并生成BeanDefination,只是暂时找出来
	Set beanMethods = retrieveBeanMethodMetadata(sourceClass);
	for (MethodMetadata methodMetadata : beanMethods) {
		configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
	}

	// Process default methods on interfaces
	// 解析配置类所实现的接口中有没有default的方法上是加了@Bean的,但并没有真正处理@Bean,只是暂时找出来
	processInterfaces(configClass, sourceClass);

	// Process superclass, if any
	if (sourceClass.getMetadata().hasSuperClass()) {
		String superclass = sourceClass.getMetadata().getSuperClassName();
		if (superclass != null && !superclass.startsWith("java") &&
				!this.knownSuperclasses.containsKey(superclass)) {
			this.knownSuperclasses.put(superclass, configClass);
			// Superclass found, return its annotation metadata and recurse
			return sourceClass.getSuperClass();
		}
	}

	// No superclass -> processing is complete
	return null;
}

4. 针对解析过的配置类去加载BeanDefinition

4.1. 根据解析过的配置类去生成对应的BeanDefinition

回到processConfigBeanDefinitions()这个方法，由于执行parser.parse(candidates)解析配置类，

有可能会得到其它配置类，而所有的这些配置类中，如果有@Bean注解的方法、或者加了@ImportResource注解、或者是实现了ImportBeanDefinitionRegistrar接口的，在解析配置类的时候，只是把它们作为配置类的属性存储起来，还没有真正的处理，到this.reader.loadBeanDefinitions(configClasses)这一步才会真正的处理，生成BeanDefinition；

public void loadBeanDefinitions(Set configurationModel) {
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
	for (ConfigurationClass configClass : configurationModel) {
		loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
	}
}

private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

	if (trackedConditionEvaluator.shouldSkip(configClass)) {
		String beanName = configClass.getBeanName();
		if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
				this.registry.removeBeanDefinition(beanName);
		}
			this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
			return;
	}

	if (configClass.isImported()) {
		// 将被导入的类生成BeanDefinition并注册到Spring容器中
		// @Component的内部类,@Import所导入的类都是被导入的类
		registerBeanDefinitionForImportedConfigurationClass(configClass);
	}

	// @Bean生成BeanDefinition并注册
	for (BeanMethod beanMethod : configClass.getBeanMethods()) {
		loadBeanDefinitionsForBeanMethod(beanMethod);
	}

	// 处理@ImportResource("spring.xml")
	loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

	// 处理ImportBeanDefinitionRegistrar，调用registerBeanDefinitions()方法
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

4.2.  基于上述 4.1. 如果有新的BeanDefinition生成，还需要去判断是不是配置类、去解析，所以，这也是会出现do ...while循环的原因；

do {
			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");

			// 解析配置类,会把每个BeanDefinitionHolder首先封装为ConfigurationClass
			// 在这个过程中会进行扫描、导入等步骤,从而会找到其他的ConfigurationClass
			// 解析配置类的结果是什么？
			parser.parse(candidates);  // AppConfig.class--->BeanDefinition
			parser.validate();

			//由于解析配置类有可能会得到其它配置类,这里获取到的是目前为止所有的配置类,而且这些配置类是被解析过了的,但并不表示整个Spring容器只有这些配置类
			//例如解析AppConfig.class后,会得到其它的一些配置类
			// configClasses相当于就是解析之后的结果
			Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
			configClasses.removeAll(alreadyParsed);

			// Read the model and create bean definitions based on its content
			if (this.reader == null) {
				this.reader = new ConfigurationClassBeanDefinitionReader(
						registry, this.sourceExtractor, this.resourceLoader, this.environment,
						this.importBeanNameGenerator, parser.getImportRegistry());
			}
			// 针对所有解析过的ConfigurationClass,去加载BeanDefinition,通常情况下一个配置类会对应一个BeanDefinition,不过也有可能一个配置类对应多个BeanDefinition
			// 比如一个配置类中有多个加了@Bean注解的方法,会对应多个BeanDefination,一个配置类配置了@ImportResource,基本也会得到多个BeanDefintion
			//比如在下面这行代码执行之前,AppConfig1,是没有被解析过的,在这里才会被解析到,并且会生成BeanDefination,所以这里有可能又会得到一些新的BeanDefination
			this.reader.loadBeanDefinitions(configClasses);

			alreadyParsed.addAll(configClasses);
			processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

			// candidates中存的是BeanDefinition，configClasses中存的是ConfigurationClass
			candidates.clear();

			// 如果发现BeanDefinition增加了,则有可能增加了配置类
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				Set alreadyParsedClasses = new HashSet<>();
				for (ConfigurationClass configurationClass : alreadyParsed) {
					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
				}
				for (String candidateName : newCandidateNames) {
					if (!oldCandidateNames.contains(candidateName)) {
						BeanDefinition bd = registry.getBeanDefinition(candidateName);

						// 检查多出来的BeanDefinition是不是配置类，需不需要解析
						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
								!alreadyParsedClasses.contains(bd.getBeanClassName())) {
							candidates.add(new BeanDefinitionHolder(bd, candidateName));
						}
					}
				}
				candidateNames = newCandidateNames;
			}
	}
	while (!candidates.isEmpty());

四、关于@Configuration注解

1. 生成代理类

执行完BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法后，紧接着会执行postProcessBeanFactory()方法，在postProcessBeanFactory()方法中会为加了Configuration注解的配置类，生成代理类，注意：只有是full配置类时，才会为其生成代理类；

/**
 * Prepare the Configuration classes for servicing bean requests at runtime
 * by replacing them with CGLIB-enhanced subclasses.
 */
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	int factoryId = System.identityHashCode(beanFactory);
	if (this.factoriesPostProcessed.contains(factoryId)) {
		throw new IllegalStateException(
				"postProcessBeanFactory already called on this post-processor against " + beanFactory);
	}
	this.factoriesPostProcessed.add(factoryId);
	if (!this.registriesPostProcessed.contains(factoryId)) {
		// BeanDefinitionRegistryPostProcessor hook apparently not supported...
		// Simply call processConfigurationClasses lazily at this point then.
		processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
	}

	// 增强配置类,代理加了Configuration注解的配置类
	enhanceConfigurationClasses(beanFactory);

	beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
		StartupStep enhanceConfigClasses = this.applicationStartup.start("spring.context.config-classes.enhance");
		Map configBeanDefs = new LinkedHashMap<>();

		// 遍历，找出配置类
		for (String beanName : beanFactory.getBeanDefinitionNames()) {
			BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
			Object configClassAttr = beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);
			AnnotationMetadata annotationMetadata = null;
			MethodMetadata methodMetadata = null;
			if (beanDef instanceof AnnotatedBeanDefinition) {
				AnnotatedBeanDefinition annotatedBeanDefinition = (AnnotatedBeanDefinition) beanDef;
				annotationMetadata = annotatedBeanDefinition.getMetadata();
				methodMetadata = annotatedBeanDefinition.getFactoryMethodMetadata();
			}
			if ((configClassAttr != null || methodMetadata != null) && beanDef instanceof AbstractBeanDefinition) {
				// Configuration class (full or lite) or a configuration-derived @Bean method
				// -> eagerly resolve bean class at this point, unless it's a 'lite' configuration
				// or component class without @Bean methods.
				AbstractBeanDefinition abd = (AbstractBeanDefinition) beanDef;

				// 没有加载类就去加载
				if (!abd.hasBeanClass()) {
					boolean liteConfigurationCandidateWithoutBeanMethods =
							(ConfigurationClassUtils.CONFIGURATION_CLASS_LITE.equals(configClassAttr) &&
								annotationMetadata != null && !ConfigurationClassUtils.hasBeanMethods(annotationMetadata));
					if (!liteConfigurationCandidateWithoutBeanMethods) {
						try {
							abd.resolveBeanClass(this.beanClassLoader);
						}
						catch (Throwable ex) {
							throw new IllegalStateException(
									"Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
						}
					}
				}
			}
			if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
				if (!(beanDef instanceof AbstractBeanDefinition)) {
					throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
							beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
				}
				else if (logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
					logger.info("Cannot enhance @Configuration bean definition '" + beanName +
							"' since its singleton instance has been created too early. The typical cause " +
							"is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
							"return type: Consider declaring such methods as 'static'.");
				}
				configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
			}
		}
		if (configBeanDefs.isEmpty() || NativeDetector.inNativeImage()) {
			// nothing to enhance -> return immediately
			enhanceConfigClasses.end();
			return;
		}

		// 生成代理类,并设置到BeanDefinition中,针对的是full配置类
		ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
		for (Map.Entry entry : configBeanDefs.entrySet()) {
			AbstractBeanDefinition beanDef = entry.getValue();
			// If a @Configuration class gets proxied, always proxy the target class
			beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
			// Set enhanced subclass of the user-specified bean class
			Class configClass = beanDef.getBeanClass();  // Appconfig
			// 生成代理类
			Class enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
			if (configClass != enhancedClass) {
				if (logger.isTraceEnabled()) {
					logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
							"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
				}
				//将当前配置类对应的BeanDefination对象的beanClass属性,设置成代理类
				//所以当根据这些BeanDefination创建Bean的时候,生成出来的是代理对象
				beanDef.setBeanClass(enhancedClass);
			}
		}
		enhanceConfigClasses.tag("classCount", () -> String.valueOf(configBeanDefs.keySet().size())).end();
}

2. 代理类的作用

由于生成代理类后，当前配置类对应的BeanDefination对象中的beanClass属性会被设置为代理类，所以当根据这些BeanDefination创建Bean的时候，创建出来的就是代理对象了，那么在执行代理对象中的方法的时候(比如，加了@Bean注解的方法)，就有可能执行的是代理逻辑了，那代理逻辑解决的问题是什么？

① 如果代理对象正在执行的方法就是当前正在创建的Bean的工厂方法，那就直接执行对应的方法得到对象作为Bean，什么意思呢？例如，Spring在创建OrderService类型的Bean的时候会在创建Bean实例(即createBeanInstance())这一步，处理@Bean对应的BeanDefinition，那么就会调用orderService()方法实例化OrderService对象，并且会记录当前正在调用的factoryMethod(也就是orderService())，由于此时的factoryBean是代理对象，所以会执行代理逻辑；调用orderService()方法实例化OrderService对象如下：

@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
		@Nullable Object factoryBean, final Method factoryMethod, Object... args) {

	try {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction) () -> {
				ReflectionUtils.makeAccessible(factoryMethod);
				return null;
			});
		}
		else {
			ReflectionUtils.makeAccessible(factoryMethod);
		}

		Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
		try {
			currentlyInvokedFactoryMethod.set(factoryMethod);
			// factoryBean就是AppConfig的代理对象（如果加了@Configuration）
			// factoryMethod就是@Bean修饰的方法
			//如果factoryBean是代理对象,就会走代理逻辑
			Object result = factoryMethod.invoke(factoryBean, args);
			if (result == null) {
				result = new NullBean();
			}
				return result;
			}
		finally {
			if (priorInvokedFactoryMethod != null) {
				currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
			}
			else {
				currentlyInvokedFactoryMethod.remove();
			}
		}
	}
	catch (IllegalArgumentException ex) {
		throw new BeanInstantiationException(factoryMethod,
				"Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
				"args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
	}
	catch (IllegalAccessException ex) {
		throw new BeanInstantiationException(factoryMethod,
				"Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
	}
	catch (InvocationTargetException ex) {
		String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
		if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
					((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) {
			msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
					"declaring the factory method as static for independence from its containing instance. " + msg;
		}
		throw new BeanInstantiationException(factoryMethod, msg, ex.getTargetException());
	}
} 
  
代理逻辑如下：
 
  
public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
					MethodProxy cglibMethodProxy) throws Throwable {
			// enhancedConfigInstance是代理对象
			ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
			String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);

			// Determine whether this bean is a scoped-proxy
			if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {
				String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
				if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
					beanName = scopedBeanName;
				}
			}

			// To handle the case of an inter-bean method reference, we must explicitly check the
			// container for already cached instances.

			// First, check to see if the requested bean is a FactoryBean. If so, create a subclass
			// proxy that intercepts calls to getObject() and returns any cached bean instance.
			// This ensures that the semantics of calling a FactoryBean from within @Bean methods
			// is the same as that of referring to a FactoryBean within XML. See SPR-6602.
			if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&
					factoryContainsBean(beanFactory, beanName)) {
				Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
				if (factoryBean instanceof ScopedProxyFactoryBean) {
					// Scoped proxy factory beans are a special case and should not be further proxied
				}
				else {
					// It is a candidate FactoryBean - go ahead with enhancement
					return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
				}
			}

			// 如果代理对象正在执行的方法就是当前正在创建Bean的工厂方法，那就直接执行对应的方法得到对象作为Bean
			if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
				// The factory is calling the bean method in order to instantiate and register the bean
				// (i.e. via a getBean() call) -> invoke the super implementation of the method to actually
				// create the bean instance.
				if (logger.isInfoEnabled() &&
						BeanFactoryPostProcessor.class.isAssignableFrom(beanMethod.getReturnType())) {
					logger.info(String.format("@Bean method %s.%s is non-static and returns an object " +
									"assignable to Spring's BeanFactoryPostProcessor interface. This will " +
									"result in a failure to process annotations such as @Autowired, " +
									"@Resource and @PostConstruct within the method's declaring " +
									"@Configuration class. Add the 'static' modifier to this method to avoid " +
									"these container lifecycle issues; see @Bean javadoc for complete details.",
							beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName()));
				}
				// 注意这里传入的是代理对象，相当于在执行父类的方法，注意和Spring事务做区分
				return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
			}

			// 如果代理对象正在执行的方法不是正在创建Bean的方法，那就直接根据方法的名字去Spring容器中获取
			return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
}
 
  
② 如果代理对象正在执行的方法不是正在创建的Bean的工厂方法，那就直接根据方法的名字去Spring容器中获取，这样可以保证@Bean方法的单例；上述①②情况代码示例如下：
 
  
@Configuration
public class AppConfig {

// 这里的orderService()方法会调三次,还有一次是Spring启动,创建OrderService类型的Bean的时候会调

    @Bean
	public UserService userService() {
		System.out.println(orderService());
		System.out.println(orderService());
		return new UserService();
	}


	@Bean
	public OrderService orderService(){
		return new OrderService();
	}

}
 
  
3. 总结
 
  
@Bean之间的方法调用是怎么保证单例的？（ @Configuration加与不加的区别是什么？）
 
  
1.如果希望@Bean的方法返回是对象是单例 需要在类上面加上@Configuration；
 
  
2.Spring 会在invokeBeanFactoryPostProcessor 中，通过内置BeanFactoryPostProcessor会生成CGLib动态代理对象；
 
  
3.当@Bean方法进行互调时， 则会通过CGLIB进行增强，通过调用的方法名作为Bean的名称去ioc容器中获取，进而保证了@Bean方法的单例；
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(#Spring源码,Spring全家桶,spring,java,后端)

        

            

                
    
                    
  • 【JavaScript】11-JS高阶技巧
                        beibeibeiooo
JavaScript【已完结】javascript前端ecmascriptes6
                        
    本文介绍JS中的一些高阶技巧。目录1.深浅拷贝1.1浅拷贝1.2深拷贝1.2.1通过递归实现1.2.2lodash/cloneDeep1.2.3JSON.stringify()2.异常处理2.1throw抛异常2.2try/catch捕获异常2.3debugger3.处理this3.1this指向3.1.1普通函数this3.1.2箭头函数的this3.2改变this3.2.1call方法改变3.
    
                    
    • 
                    
  • el-select多选选择器（在懒加载的基础上） 重磅：实现模糊搜索+多选+未加载数据的正确回显！！
                        SerendipityM
javascript前端开发语言vue.jshtml5
                        
    项目需求：由于表单中的一个el-select中的数据过多，下拉框用户体验不好，因此需要做成有懒加载且分页的下拉框。后又因为该功能需要多选，并且打开表单要能够正确回显。这些需求加起来，导致问题变得复杂起来。我在网上也看了许多文章，没有找到好的解决方案。因此我将自己的记录下来，还望各位指点！！！（本项目请求后端需要传id，page，size，name）(name的格式为JSON形式的[id:1,nam
    
                    
    • 
                    
  • java面向对象基础
                        miehamiha
java开发语言
                        
    引入三大特征封装核心思想就是“隐藏细节”、“数据安全”，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。所有的内容对外部不可见。继承子类可以继承父类的属性和方法，并对其进行拓展。将其他的功能继承下来继续发展。多态同一种类型的对象执行同一个方法时可以表现出不同的行为特征。通过继承的上下转型、接口的回调以及方法的重写和重载
    
                    
    • 
                    
  • 如何用PHP开发一个api数据接口
                        幽蓝计划
php
                        
    对于一个iOS开发者来说，我一直觉得会写接口是一件很酷的事情，因为它可以实时修改前台数据，而不像App一样需要更新版本和接受审核。更重要的是，它意味着你的技术完成了一个闭环，可以独自完成一整个项目的开发。PHP是我接触的第一个脚本语言，使用之后更是感觉PHP功能强大，开发过程非常友好方便，虽然之后也学习过Python、JavaScript等语言，但现在还是习惯使用PHP，下面就来介绍一下如何用PH
    
                    
    • 
                    
  • Java 环境配置与 JAR 文件问题解决全攻略
                        不羁。。
杂记丨每天亿点小知识javajar开发语言
                        
    目录一、Java环境配置指南1.Windows系统配置步骤1.1下载安装JDK1.2配置环境变量2.Linux/macOS系统配置2.1终端命令配置二、JAR文件问题诊断与修复1.检查JAR文件完整性1.1命令行验证1.2哈希值校验2.依赖库管理方案2.1Maven依赖配置示例2.2命令行指定依赖三、常见问题解决方案1.环境变量不生效处理1.1清除系统缓存1.2路径优先级调整2.旧版本残留处理2.
    
                    
    • 
                    
  • COMP 315: Cloud Computing for E-Commerce
                        
后端
                        
    Assignment1:JavascriptCOMP315:CloudComputingforE-CommerceFebruary20251IntroductionAcommontaskwhenbackendprogrammingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorinco
    
                    
    • 
                    
  • MDC-Mapped Diagnostic Context（映射诊断上下文）
                        NEUMaple
微服务springbootjavaMDC
                        
    MDC，全称为MappedDiagnosticContext（映射诊断上下文），是SLF4J（SimpleLoggingFacadeforJava）提供的一种机制，用于在多线程应用中存储和管理与特定线程相关的上下文信息。这种机制特别适用于需要跨多个方法调用或服务边界传递诊断信息的场景，例如跟踪分布式系统中的请求流。MDC的主要用途日志关联：在分布式系统或多线程应用中，MDC可以用来携带一些上下文信
    
                    
    • 
                    
  • SpringBoot集成Pulsar 生产者与消费者示例代码
                        七维大脑
技术&解决方案分享java中间件
                        
    目录介绍功能特点一、导入pulsar依赖二、pulsar配置（示例为yml文件）三、生产者示例代码四、消费者代码介绍Pulsar是一个多租户、高性能的服务器到服务器消息传递解决方案。Pulsar最初由Yahoo开发，由Apache软件基金会管理。功能特点Pulsar的主要功能如下：原生支持Pulsar实例中的多个集群，并可跨集群无缝地复制消息。非常低的发布和端到端延迟。无缝扩展到超过一百万个主题。
    
                    
    • 
                    
  • SOFAStack-00-sofa 技术栈概览
                        老马啸西风
sofa架构监控阿里云系统架构
                        
    SOFAStack前言大家好，我是老马。sofastack其实出来很久了，第一次应该是在2022年左右开始关注，但是一直没有深入研究。最近想学习一下SOFA对于生态的设计和思考。核心项目⚙️SOFABootGitHub:sofastack/sofa-boot|★3.8k功能：企业级SpringBoot增强框架，支持模块化开发、类隔离、日志隔离，提供健康检查、异步初始化等特性。SOFARPCGitH
    
                    
    • 
                    
  • Spring Boot与Hazelcast整合教程
                        嘵奇
提升自己springboot后端java
                        
    精心整理了最新的面试资料和简历模板，有需要的可以自行获取点击前往百度网盘获取点击前往夸克网盘获取SpringBoot与Hazelcast整合教程简介Hazelcast是一个开源的内存数据网格（IMDG），提供分布式缓存、计算和数据结构功能。与SpringBoot整合后，可以快速实现分布式缓存、会话共享等功能。本教程将演示如何将Hazelcast嵌入SpringBoot应用。环境准备JDK17+Sp
    
                    
    • 
                    
  • Java：Apache HttpClient中HttpRoute用法的介绍
                        netyeaxi
Javajavaapache开发语言
                        
    当使用ApacheHttpClient组件时，经常会用到它的连接池组件。典型的代码如下：PoolingHttpClientConnectionManagerconnectionManager=newPoolingHttpClientConnectionManager();connectionManager.setMaxTotal(httpConfig.getMaxPoolTotal());conn
    
                    
    • 
                    
  • 挑战20天学完JavaSE第四天——方法的定义、调用和方法重载
                        呆呆why care
挑战20天学完javaSEjava笔记改行学it程序人生
                        
    Java方法是语句的集合，它们在一起执行一个功能。方法是解决一类问题的步骤的有序组合。方法包含于类或对象中。方法在程序中被创建，在其他地方被引用。设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。方法的命名规则：首字母小写驼峰命名方法的定义Java的方法类似于其它语言的函数，是一段用来完
    
                    
    • 
                    
  • java struts jxl 导入导出Excel（无模板）
                        weixin_30437847
java数据库javascriptViewUI
                        
    jar包：importjavax.servlet.http.HttpServletResponse;importjava.io.OutputStream;importjava.io.File;importjxl.DateCell;importjxl.Sheet;importjxl.Workbook;importjxl.format.Alignment;importjxl.format.Border
    
                    
    • 
                    
  • ZooKeeper集群高可用性测试与实践：从规划到故障模拟
                        磐基Stack专业服务团队
Zookeeperzookeeper可用性测试
                        
    #作者：任少近文章目录ZooKeeper集群环境规划1.集群数据一致性测试2.集群节点故障测试ZooKeeper集群高可用性测试的主要目的是确保在分布式环境中，ZooKeeper服务能够持续提供一致性和高可用性的协调服务。ZooKeeper集群环境规划节点ipZooKeeper版本java版本对外端口集群通信端口集群选举端口192.168.x.xZooKeeper-3.6.11.8.0_33221
    
                    
    • 
                    
  • PHP 爬虫实战：爬取淘宝商品详情数据
                        EcomDataMiner
php爬虫开发语言
                        
    随着互联网技术的发展，数据爬取越来越成为了数据分析、机器学习等领域的重要前置技能。而在这其中，爬虫技术更是不可或缺。php作为一门广泛使用的后端编程语言，其在爬虫领域同样也有着广泛应用和优势。本文将以爬取斗鱼直播数据为例，介绍php爬虫的实战应用。准备工作在开始爬虫之前，我们需要做一些准备工作。首先，需要搭建一个本地服务器环境，推荐使用WAMP、XAMPP等集成化工具，方便部署PHP环境。其次，我
    
                    
    • 
                    
  • Java File 类与文件操作
                        代码先锋者
java开发java开发语言
                        
    一、引言在Java编程中，文件操作是一项非常常见且重要的任务。无论是读取配置文件、保存用户数据，还是进行日志记录，都离不开对文件的操作。Java提供了File类来表示文件和目录的抽象路径名，通过该类可以对文件和目录进行创建、删除、重命名等操作。同时，Java还提供了一系列的输入输出流类，用于对文件内容进行读写操作。本文将详细介绍Java中File类的使用以及相关的文件操作案例。二、File类概述2
    
                    
    • 
                    
  • Java 基础数据类型
                        代码先锋者
java开发java开发语言
                        
    一、引言在Java中每个变量都必须先声明其数据类型，才能使用（即Java是强类型语言）。Java的数据类型分为两大类：基本数据类型（PrimitiveDataTypes）和引用数据类型（ReferenceDataTypes）。二、基本数据类型分类Java有8种基本数据类型（如下图所示），可分为四大类（整数型，浮点型，字符型和布尔型）：8大基本数据类型具体位数、取值范围和默认值等如下表所示：数据类型
    
                    
    • 
                    
  • 【大模型系列】SFT（Supervised Fine-Tuning，监督微调）
                        Kwan的解忧杂货铺@新空间代码工作室
s2AIGC大模型
                        
    欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
    
                    
    • 
                    
  • 编程自学指南：java程序设计开发，Java 对象创建的6种方式，从new到反射：Java 对象创建全解析，new关键字，反射机制，克隆（Clone），反序列化 ，工厂模式，建造者模式
                        zl515035644
java自学指南java开发语言
                        
    编程自学指南：java程序设计开发，Java对象创建的几种方式一、课程信息学习目标掌握6种主流对象创建方式的实现方法理解每种方式的适用场景与优缺点能根据需求选择最合适的创建方式避免对象创建中的常见错误（如构造器权限问题）二、课程导入：生活中的"创建"场景类比买现成的→new关键字（最常用）复制已有物品→克隆（Clone）按图纸定制→工厂模式（复杂对象）反序列化→从文件/网络恢复对象三、主流创建方式
    
                    
    • 
                    
  • Java 泛型
                        代码先锋者
java开发java开发语言
                        
    一、引言在Java编程中，泛型是一项强大的特性，它允许在类、接口和方法的定义中使用类型参数。泛型提供了类型安全的集合，避免了在运行时进行类型转换的风险，提高了代码的可读性和可维护性。二、泛型的基本概念2.1泛型的定义泛型，即“参数化类型”，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。2.2
    
                    
    • 
                    
  • 使用maven打包项目报错Please refer to...
                        编程_大白
日常mavenjava
                        
    报错描述：PleaserefertoD:\code\java\project_test\usercenter\usercenter_backend\target\surefire-reportsfortheindividualtestresults.Pleaserefertodumpfiles(ifanyexist)[date].dump,[date]-jvmRun[N].dumpand[date
    
                    
    • 
                    
  • 探究Three.js中模型移动与旋转的交互逻辑
                        Front_Yue
3D技术实践指南javascriptthree.js3d
                        
    前言Three.js作为一个功能强大的JavaScript3D库，极大地简化了在网页上创建和展示3D图形的过程。它在游戏开发、产品展示、虚拟现实等众多领域都被广泛应用。通过Three.js，开发者能够轻松创建出复杂的三维场景和交互性强的3D应用，为用户带来沉浸式的体验。一、模型移动的交互逻辑实现（一）键盘控制模型移动利用键盘事件来控制模型在三维空间中的位置移动，是一种常见且便捷的交互方式。以下为具
    
                    
    • 
                    
  • 从零开始：使用原生JS打造简易飞机大战游戏
                        西域情歌

                        
    本文还有配套的精品资源，点击获取简介：在本教程中，我们将探讨如何利用原生JavaScript的特性，包括事件处理、DOM操作、定时器和音频处理，来构建一个基础的“飞机大战”游戏。该游戏的核心元素包括玩家飞机、敌机、子弹和碰撞检测，它们通过HTML和CSS展现在页面上。通过编写JavaScript脚本，我们实现游戏对象的创建与状态管理，响应用户的键盘和点击事件，更新游戏内容，并通过定时器维护游戏循环
    
                    
    • 
                    
  • Kubernetes学习笔记-移除Nacos迁移至K8s
                        人生偌只如初见
KubernetesJ2EEkubernetesk8sjava
                        
    项目服务的配置管理和服务注册发现由原先的Nacos全面迁移到Kubernetes上。一、移除Nacos移除Nacos组件依赖。com.alibaba.cloudspring-cloud-starter-alibaba-nacos-discoverycom.alibaba.cloudspring-cloud-starter-alibaba-nacos-configorg.springframewor
    
                    
    • 
                    
  • 【Java学习日记6】：字面量的分类与使用
                        小蛋6g
Java学习日记java开发语言
                        
    一、字面量的定义与作用字面量是程序中直接书写的数据值，无需通过变量或计算获取。它用于表示固定的值，如数字、字符、布尔值等，例如：数字100、字符串"Hello"、字符'A'等。字面量告诉编译器数据的类型和值。字面量就是告诉程序员:数据在程序中的书写格式.---二、字面量的分类Java中的字面量按数据类型可分为以下六类：类型说明示例整数类型不带小数点的数字123,-456小数类型带小数点的数字3.1
    
                    
    • 
                    
  • Python, Java, C ++开发全球热能动态监测APP
                        Geeker-2025
pythonjavac++
                        
    开发一个“全球热能动态监测APP”是一个非常有意义的想法，尤其是在能源管理和环境保护领域。以下是开发该APP的详细思路和技术实现方案，分别针对Python、Java和C++。---###**功能需求分析**1.**全球热能数据展示**：-各国或地区的热能生产、消费和进出口数据。-实时监测热能动态（如发电厂的热能输出、温度变化等）。2.**地图可视化**：-在地图上标注热能发电厂的位置。-使用颜色或
    
                    
    • 
                    
  • React 18 如何定义变量，及赋值 与渲染
                        痴心阿文
Reactreact.jsjavascript前端
                        
    React18中，定义变量、赋值和渲染的方式因变量的用途和作用域不同而有所差异，下面为你详细介绍不同场景下的实现方法。1.函数组件内定义普通变量在函数组件里，你可以像在普通JavaScript函数中一样定义变量，并且这些变量会在每次组件重新渲染时重新创建。importReactfrom'react';constMyComponent=()=>{//定义普通变量并赋值constmessage='He
    
                    
    • 
                    
  • Java基础笔记（小白友好版）
                        代码什么的真不会呀
java笔记开发语言
                        
    Java基础笔记（小白友好版）1.Java简介Java是一种广泛使用的计算机编程语言，由詹姆斯·高斯林（JamesGosling）在1995年创建Java的口号是"一次编写，到处运行"（WriteOnce,RunAnywhere）Java程序需要先编译成字节码（.class文件），然后在Java虚拟机（JVM）上运行主要特点：面向对象：一切皆对象，代码更清晰易懂平台无关性：可以在Windows、M
    
                    
    • 
                    
  • 使用Three.js渲染器创建炫酷3D场景
                        Front_Yue
3D技术实践指南javascriptthree.js3d
                        
    引言在当今数字化的时代，3D图形技术正以其独特的魅力在各个领域掀起波澜。从影视制作到游戏开发，从虚拟现实到网页交互，3D场景以其强烈的视觉冲击力和沉浸式的体验，成为了吸引用户、传达信息的重要手段。而Three.js，作为一款功能强大且广受欢迎的JavaScript3D库，为我们提供了便捷、高效的途径来创建令人炫目的3D场景。本文将深入探讨使用Three.js渲染器创建炫酷3D场景的方方面面，带领读
    
                    
    • 
                    
  • java中vector和list_java中vector和list的区别
                        Creamy络

                        
    java中vector和list的区别发布时间：2020-06-1917:07:11来源：亿速云阅读：106作者：元一vector的概念Vector类是在java中可以实现自动增长的对象数组，vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector的使用连续存储结构：vector是可以实现动态增长的对象数组，支持对数组高效率的访问和在数
    
                    
    • 
                                
  • PHP，安卓，UI，java，linux视频教程合集
                                    cocos2d-x小菜
javaUIPHPandroidlinux
                                    
    ╔-----------------------------------╗┆                           
    
                                
    • 
                                
  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。
                                    bozch
.net.net mvc
                                    
    在.net mvc5中，在执行某一操作的时候，出现了如下错误： 
      各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 
经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 
回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  
&
    
                                
    • 
                                
  • Java 对象大小的计算
                                    e200702084
java
                                    
                              Java对象的大小 
 
如何计算一个对象的大小呢？ 
 
 
   
    
                                
    • 
                                
  • Mybatis Spring
                                    171815164
mybatis
                                    
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
CustomerService userService = (CustomerService) ac.getBean("customerService");
Customer cust
    
                                
    • 
                                
  • JVM 不稳定参数
                                    g21121
jvm
                                    
            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
    
                                
    • 
                                
  • 用户自动登录网站
                                    永夜-极光
用户
                                    
    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 
2.思路:将用户的信息保存为cookie 
           每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
    
                                
    • 
                                
  • centos7 安装后失去win7的引导记录
                                    程序员是怎么炼成的
操作系统
                                    
    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
    
                                
    • 
                                
  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载
                                    aijuans
oracle
                                    
    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
    
                                
    • 
                                
  • JavaEE开源快速开发平台G4Studio_V3.2发布了
                                    無為子
AOPoraclemysqljavaeeG4Studio
                                    
      
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。 
  
访问G4Studio网站  
http://www.g4it.org      
G4Studio_V3.2版本变更日志 
功能新增 
(1).新增了系统右下角滑出提示窗口功能。 
(2).新增了文件资源的Zip压缩和解压缩
    
                                
    • 
                                
  • Oracle常用的单行函数应用技巧总结
                                    百合不是茶
日期函数转换函数(核心)数字函数通用函数(核心)字符函数
                                    
    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 
一:字符函数: 
   .UPPER(字符串) 将字符串转为大写
   .LOWER (字符串) 将字符串转为小写 
   .INITCAP(字符串) 将首字母大写
   .LENGTH (字符串) 字符串的长度
   .REPLACE(字符串,'A','_') 将字符串字符A转换成_

    
                                
    • 
                                
  • Mockito异常测试实例
                                    bijian1013
java单元测试mockito
                                    
    Mockito异常测试实例： 
package com.bijian.study;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;

import org.mockito.
    
                                
    • 
                                
  • GA与量子恒道统计
                                    Bill_chen
JavaScript浏览器百度Google防火墙
                                    
    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下： 
  
为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 
首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
    
                                
    • 
                                
  • 【Linux命令三】Top命令
                                    bit1129
linux命令
                                    
    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果： 
  
  
top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99
Tasks: 202 total,   4 running, 198 sl
    
                                
    • 
                                
  • spring四种依赖注入方式
                                    白糖_
spring
                                    
       平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
    
                                
    • 
                                
  • angular.injector
                                    boyitech
AngularJSAngularJS API
                                    
    angular.injector 
   描述:   创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.        使用方法:   angular.injector(modules, [strictDi])        参数详解:      Param Type Details   mod
    
                                
    • 
                                
  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待
                                    bylijinnan
Integer
                                    
    

public class PC {

	/**
	 * 题目：生产者-消费者。
	 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。
	 */
	
	private static final Integer[] val=new Integer[10];
	private static
    
                                
    • 
                                
  • 使用Struts2.2.1配置
                                    Chen.H
apachespringWebxmlstruts
                                    
    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar 
struts2-core-2.2.1.jar struts2-sp
    
                                
    • 
                                
  • [职业与教育]青春之歌
                                    comsci
教育
                                    
     
 
       每个人都有自己的青春之歌............但是我要说的却不是青春... 
 
       大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的.... 
 
  &nbs
    
                                
    • 
                                
  • oracle连接(join)中使用using关键字
                                    daizj
JOINoraclesqlusing
                                    
    在oracle连接(join)中使用using关键字 
34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. 
Evaluate the following SQL statement: 
SELECT oi.order_id, product_id, order_date 
FRO
    
                                
    • 
                                
  • NIO示例
                                    daysinsun
nio
                                    
    NIO服务端代码： 
 

public class NIOServer {
	
	private Selector selector;

	
	public void startServer(int port) throws IOException {

		ServerSocketChannel serverChannel = ServerSocketChannel.open(
    
                                
    • 
                                
  • C语言学习homework1
                                    dcj3sjt126com
chomework
                                    
    0、 课堂练习做完 
1、使用sizeof计算出你所知道的所有的类型占用的空间。 
int x; 
sizeof(x); 
  
sizeof(int); 
  
# include <stdio.h>

int main(void)
{
	int x1;
	char x2;
	double x3;
	float x4;

	printf(&quo
    
                                
    • 
                                
  • select in order by , mysql排序
                                    dcj3sjt126com
mysql
                                    
    If i select like this: 
SELECT id FROM users WHERE id IN(3,4,8,1); 
This by default will select users in this order 
1,3,4,8, 
I would like to select them in the same order that i put IN() values so: 
    
                                
    • 
                                
  • 页面校验-新建项目
                                    fanxiaolong
页面校验
                                    
    $(document).ready(
	function() {
			var flag = true;
		$('#changeform').submit(function() {
			var projectScValNull = true;
			var s ="";
			var parent_id = $("#parent_id").v
    
                                
    • 
                                
  • Ehcache（02）——ehcache.xml简介
                                    234390216
ehcacheehcache.xml简介
                                    
    ehcache.xml简介 
  
       ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
    
                                
    • 
                                
  • junit 4.11中三个新功能
                                    jackyrong
java
                                    
    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 
 
 


import static org.junit.Assert.assertEquals;
 
import java.util.Arrays;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runn
    
                                
    • 
                                
  • 国外程序员爱用苹果Mac电脑的10大理由
                                    php教程分享
windowsPHPunixMicrosoftperl
                                    
    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 
1、Mac OS X 是基于 Unix 的 
这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
    
                                
    • 
                                
  • 位运算、异或的实际应用
                                    wenjinglian
位运算
                                    
    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。 
      二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。 
      三． 位操作与空间压缩，针对筛素数进行空间压缩。 
   &n
    
                                
    • 
                                
  • weblogic部署项目出现的一些问题（持续补充中……）
                                    Everyday都不同
weblogic部署失败
                                    
    好吧，weblogic的问题确实…… 
  
问题一： 
org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
    
                                
    • 
                                
  • tomcat7性能调优（01）
                                    toknowme
tomcat7
                                    
      
    
Tomcat优化：   1、最大连接数最大线程等设置    
<Connector port="8082" protocol="HTTP/1.1" 
               useBodyEncodingForURI="t
    
                                
    • 
                                
  • PO VO DAO DTO BO TO概念与区别
                                    xp9802
javaDAO设计模式bean领域模型
                                    
    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 
它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
    
                                
    •