沉着的卷心菜
沉着的卷心菜

SpringAOP源码解析（AnnotationAwareAspectJAutoProxyCreator 注册）

下面的源码分析基于Spring版本 5.0.6.RELEASE

目录

分析创建和注册AnnotationAwareAspectJAutoProxyCreator的流程

1、瞧瞧这个注解都有啥

2、接下来重点研究 AnnotationAwareAspectJAutoProxyCreator的创建过程

3、我们来展开分析一下做为beanPostProcessor后置处理器，究竟做了哪些工作；做为BeanFactoryAware又做了哪些工作：

3.1、register()传入配置类，准备创建ioc容器

3.2、调用refresh（）刷新创建容器；

3.3、分析方法 registerBeanPostProcessors(beanFactory) ;

3.3.1、创建 internalAutoProxyCreatorr

3.3.2、初始化实例 internalAutoProxyCreator

3.3.3、注册实现了Ordered接口的BeanPostProcessor；

分析创建和注册AnnotationAwareAspectJAutoProxyCreator的流程

AnnotationAwareAspectJAutoProxyCreator 翻译过来其实就叫做 ”注解装配模式的ASPECT切面自动代理创建器”组件@EnableAspectJAutoProxy 核心从这个入手,AOP整个功能要启作用,就靠这个注解

1、瞧瞧这个注解都有啥

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 关注这个引入的类，这是整个AOP的入口
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	/**
	 * 采用JDK动态代理织入增强(实现接口的方式)；如果设为true，则采用CGLIB动态代理织入增强
	 */
	boolean proxyTargetClass() default false;

	/**
	 * 通过aop框架暴露该代理对象，让aopContext能够访问
	 */
	boolean exposeProxy() default false;

}

当 AbstractApplicationContext 执行 refresh()方法时，在 invokeBeanFactoryPostProcessors(beanFactory) 方法执行时会回调所有实现了接口 ImportBeanDefinitionRegistrar 的 registerBeanDefinitions 方法 

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
                // 注册组件 AnnotationAwareAspectJAutoProxyCreator.class，关注这行
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}
}

 

// org.springframework.aop.config.AopConfigUtils.java line 103 ，注册组件	
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
			@Nullable Object source) {
		return 
// 注册或升级 AnnotationAwareAspectJAutoProxyCreator.class，第一次我们只关注注册
registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
	}

 跟进代码看看，这里会注册一个名为  org.springframework.aop.config.internalAutoProxyCreator  的组件

	private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry,
			@Nullable Object source) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
				int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
				int requiredPriority = findPriorityForClass(cls);
				if (currentPriority < requiredPriority) {
					apcDefinition.setBeanClassName(cls.getName());
				}
			}
			return null;
		}
		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
		beanDefinition.setSource(source);
		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                // 真正注册组件的地方，该常量名为：org.springframework.aop.config.internalAutoProxyCreator
		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
		return beanDefinition;
	}

2、接下来重点研究 AnnotationAwareAspectJAutoProxyCreator的创建过程

先来一张类继承关系图

SpringAOP源码解析（AnnotationAwareAspectJAutoProxyCreator 注册）_第1张图片 标题

SmartInstantiationAwareBeanPostProcessor: bean的后置处理器；
BeanFactoryAware 能把beanFacotry bean工厂传进来 ；
通过分析以上的bean继承关系我们发现,具有BeanPostProcessor特点, 也有Aware接口的特点, 实现了BeanFactoryAware 接口；

3、我们来展开分析一下做为beanPostProcessor后置处理器，究竟做了哪些工作；做为BeanFactoryAware又做了哪些工作：

3.1、register()传入配置类，准备创建ioc容器

//	org.springframework.context.annotation.AnnotationConfigApplicationContext line 87
public AnnotationConfigApplicationContext(Class... annotatedClasses) {
		this();
                // 注册配置类，跟进去看
		register(annotatedClasses);
		refresh();
	}
//	org.springframework.context.annotation.AnnotatedBeanDefinitionReader line 213
 void doRegisterBean(Class annotatedClass, @Nullable Supplier instanceSupplier, @Nullable String name,
			@Nullable Class[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}
		abd.setInstanceSupplier(instanceSupplier);
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		if (qualifiers != null) {
			for (Class qualifier : qualifiers) {
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
			customizer.customize(abd);
		}
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                // 注册BeanDefinition
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

3.2、调用refresh（）刷新创建容器；

//	org.springframework.context.annotation.AnnotationConfigApplicationContext line 88	
public AnnotationConfigApplicationContext(Class... annotatedClasses) {
		this();
		register(annotatedClasses);
                // 刷新创建容器
		refresh();
	}
	public void refresh() throws BeansException, IllegalStateException {
		// 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
		synchronized (this.startupShutdownMonitor) {
			// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
			prepareRefresh();
			// ☆☆，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
      		        // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
      		        // 注册也只是将这些信息都保存到了ioc容器中
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
			prepareBeanFactory(beanFactory);
			try {
         		        // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
         		        // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
				postProcessBeanFactory(beanFactory);
				// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
				invokeBeanFactoryPostProcessors(beanFactory);
				    // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
         		        // BeanPostProcessor接口有两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         		        // 而BeanFactoryPostProcessor接口只有一个方法：postProcessBeanFactory
         		        // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
				registerBeanPostProcessors(beanFactory);
				// 初始化当前 ApplicationContext 的 MessageSource，国际化相关代码略过不谈
				initMessageSource();
				// 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
				initApplicationEventMulticaster();
				// 典型的模板方法，具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
				onRefresh();
				// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
				registerListeners();
				// ★★★★，初始化所有的 singleton beans，lazy-init 的除外，圈起来，重点必考题
				finishBeanFactoryInitialization(beanFactory);
				// 最后，广播事件，ApplicationContext 初始化完成
				finishRefresh();
			}
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				// 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
				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.3、分析方法 registerBeanPostProcessors(beanFactory) ;

注册bean的后置处理器，用来拦截其他bean的创建(主要关注在哪里注册AnnotationAwareAspectJAutoProxyCreator)；

	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}
  •      先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
  •      给容器中加别的BeanPostProcessor
  •      优先注册实现了PriorityOrdered接口的BeanPostProcessor；

  •      创建后置处理器 internalAutoProxyCreator

  •      注册实现了Ordered接口的BeanPostProcessor；
  •      注册没实现优先级接口的BeanPostProcessor；
  •      最后注册Spring内部的BeanPostProcessor；
// org.springframework.context.support.PostProcessorRegistrationDelegate line 186
public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		// 1）、 先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		// 2）、给容器中加额外的BeanPostProcessor
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
		List priorityOrderedPostProcessors = new ArrayList<>();
		List internalPostProcessors = new ArrayList<>();
		List orderedPostProcessorNames = new ArrayList<>();
		List nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
		List orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
                        // 4）、☆☆☆ 创建后置处理器 internalAutoProxyCreator，下文会单独讲解
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		/* 5）、☆再给容器中注册实现了Ordered接口的BeanPostProcessor,其中 AnnotationAwareAspectJAutoProxyCreator 就是在这里进行注册的*/
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);
		List nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		// 6）、注册没实现优先级接口的BeanPostProcessor；
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
		sortPostProcessors(internalPostProcessors, beanFactory);
		// 7）、注册Spring已经创建好的BeanPostProcessor；
		registerBeanPostProcessors(beanFactory, internalPostProcessors);
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

接下来分三个步骤讲解，分别是创建实例，初始化实例，初始化包含（应用工厂回调以及init方法和bean后处理器）；这两个小步骤是上文中的 创建后置处理器 internalAutoProxyCreator  的拆分；然后讲解  注册实现了Ordered接口的BeanPostProcessor； 

3.3.1、创建 internalAutoProxyCreatorr

【其实就是AnnotationAwareAspectJAutoProxyCreator】，代码跟到上述代码中提到的第4）点，对应代码 

BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);跟进去瞅瞅；

// org.springframework.beans.factory.support.AbstractBeanFactory line 239
protected  T doGetBean(final String name, @Nullable final Class requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		final String beanName = transformedBeanName(name);
		Object bean;
		// 容器此时还没有该Bean,返回 null
		Object sharedInstance = getSingleton(beanName);
		// 此处忽略部分代码 ···
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 调用父类的父类的方法创建bean
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
		// 此处忽略部分代码 ···
		}

这里看一下Bean工厂的继承关系，当前Bean工厂为 强悍的DefaultListableBeanFactory，向上转型成  AbstractBeanFactory，执行AbstractBeanFactory的方法 createBean(beanName, mbd, args)，该方法是在其父类的父类 DefaultSingletonBeanRegistry 中定义的，被其子类 AbstractAutowireCapableBeanFactory 重写，所以下面关注 AbstractAutowireCapableBeanFactory 这个类；

SpringAOP源码解析（AnnotationAwareAspectJAutoProxyCreator 注册）_第2张图片

我们看看类 AbstractAutowireCapableBeanFactory  的 方法

createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

	// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 501
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;
		// 解析bean的类型
		Class resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}
		// 处理override method方法
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}
		try {
			// 返回代理对象，AOP的实现基础就是基于这里来实现的，后续讲被切面拦截的对象创建时会详细讲解，这里暂时略过
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}
		try {
			// ☆☆☆☆ 创建对象，此时beanName = "org.springframework.aop.config.internalAutoProxyCreator",args = null;
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isDebugEnabled()) {
				logger.debug("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		// catch 部分代码省略···
	}

	// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 532
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		// bean实例包装类，用于操作bean的属性		
		BeanWrapper instanceWrapper = null;
		// 如果是单例的话，则先把工厂bean缓存中的同名bean清除
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// ☆☆ 创建bean实例，下面的代码会讲解，看看注释了解即可。
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		// 获取BeanWrapper中封装的bean的Class
		Class beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					 // bean 的生命周期之一。如果实现了MergedBeanDefinitionPostProcessor会在这里调用postProcessMergedBeanDefinition方法
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}
		// 如果RootBeanDefinition是单例的，并且开启了自动尝试解析bean之间的循环引用，并且当前bean正在创建中，则将其加入单例工厂缓存singletonFactories中，是个Map>
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			/* 将 org.springframework.aop.config.internalAutoProxyCreator 加入单例工厂缓存singletonFactories，以下截取了主要代码进行展示			
				this.singletonFactories.put(beanName, singletonFactory);
				this.earlySingletonObjects.remove(beanName);
				this.registeredSingletons.add(beanName);
			 */
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		// 对已有的bean的实例初始化  一般情况下依赖注入就在这里发生
		Object exposedObject = bean;
		try {
			// 填充bean的属性
			populateBean(beanName, mbd, instanceWrapper);
			// ☆☆☆ 初始化bean的实例，应用工厂回调以及init方法和bean后处理器
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}
		if (earlySingletonExposure) {
			// 从BeanFactory的单例缓存中获取bean的实例
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					// 处理循环依赖
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						// throw 部分代码省略···
					}
				}
			}
		}
		// 注册bean的销毁逻辑
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}
		return exposedObject;
	}

接着上述代码中的 带有注释【☆☆ 创建bean实例】的行，简单讲解下

		// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 1135
		protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
			// 此处 beanClass = org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
			Class beanClass = resolveBeanClass(mbd, beanName);
			// 中间省略大量代码，最终会执行到这行，即使用无参构造函数创建Bean
			return instantiateBean(beanName, mbd);
		}	
			// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 1228
			protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
			try {
				Object beanInstance;
				final BeanFactory parent = this;
				if (System.getSecurityManager() != null) {
					beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
							getInstantiationStrategy().instantiate(mbd, beanName, parent),
							getAccessControlContext());
				}
				else {
					// 实例化bean,跟上节奏，别掉队
					beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
				}
				// 将实例化的 bean 进行包装
				BeanWrapper bw = new BeanWrapperImpl(beanInstance);
				initBeanWrapper(bw);
				return bw;
			}
			// catch 部分代码省略···
			}
				// 此时代码跳转到了 org.springframework.beans.factory.support.SimpleInstantiationStrategy.java line 61
				public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
				if (!bd.hasMethodOverrides()) {
					Constructor constructorToUse;
					// 省略部分代码 ···
					// 使用 springframework 内部工具类创建实例，跟进去看看
					return BeanUtils.instantiateClass(constructorToUse);
				}
				else {
					return instantiateWithMethodInjection(bd, beanName, owner);
				}
				}
					// org.springframework.beans.BeanUtils line 170
					public static  T instantiateClass(Constructor ctor, Object... args) throws BeanInstantiationException {
						Assert.notNull(ctor, "Constructor must not be null");
						try {
							ReflectionUtils.makeAccessible(ctor);
							// 跟进 ctor.newInstance(args)
							return (KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
									KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
						}
						// catch 异常部分代码略
					}
						// java.lang.reflect.Constructor.java line 423
					    public T newInstance(Object ... initargs)
					        throws InstantiationException, IllegalAccessException,
					               IllegalArgumentException, InvocationTargetException
					    {
							// 省略部分代码···
					        @SuppressWarnings("unchecked")
					        // 创建 bean 的终点站到啦！！！这里利用java 反射原理创建实例
					        T inst = (T) ca.newInstance(initargs);
					        return inst;
					    } 
  
到此为止，实例已经创建完毕，接下来我看看bean 的初始化
 
  
3.3.2、初始化实例 internalAutoProxyCreator
 
  
	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction) () -> {
				// 3.3.2.1：处理Aware接口的方法回调
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			// 3.3.2.2：应用后置处理器的postProcessBeforeInitialization（）
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
		try {
			// 3.3.2.3：执行自定义的初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			// 3.3.2.4：执行后置处理器的postProcessAfterInitialization（）；
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	} 
  
分别解析一下上述代码中含注释的部分
 
  
3.3.2.1、处理Aware接口的方法回调
 
  
	private void invokeAwareMethods(final String beanName, final Object bean) {
		// 如果没有实现Aware接口，直接退出方法了；这里显然是实现了
		if (bean instanceof Aware) {
			// 没有实现 BeanNameAware
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			// 判断成功，设置类加载器
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			// ☆☆ 判断成功，设置 bean 工厂
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}
	// org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator.java line 57
	public void setBeanFactory(BeanFactory beanFactory) {
		// 调用父类方法设置工厂
		super.setBeanFactory(beanFactory);
		if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
			throw new IllegalArgumentException(
					"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
		}
		// 初始化 bean 工厂，跟进去搂一眼
		initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
	}
		// org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator.java line 79
		protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		super.initBeanFactory(beanFactory);
		if (this.aspectJAdvisorFactory == null) {
			// 创建了ReflectiveAspectJAdvisorFactory反射机制,相当于把aspectJAdvisorFactory对象通知工厂
			this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
		}
		// 通知适配器,相当于aspectJAdvisorFactory通知到构建器的适配器, 把aspectJAdvisorFactory重新包装了一下
		this.aspectJAdvisorsBuilder =
				new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
		}
 
  
3.3.2.2、应用后置处理器的postProcessBeforeInitialization();
 
  
	// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 417
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {
		Object result = existingBean;
		/*在这里接收来自Spring内部的后置处理器的洗礼（postProcessBefore），后置处理大礼包走起
		org.springframework.context.support.ApplicationContextAwareProcessor
		org.springframework.context.support.ApplicationListenerDetector
		org.springframework.context.annotation.ConfigurationClassPostProcessor
		org.springframework.context.support.PostProcessorRegistrationDelegate
		org.springframework.context.annotation.CommonAnnotationBeanPostProcessor
		org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
		org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor
		*/
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}		
 
  
3.3.2.3、执行自定义的初始化方法
 
  
	// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 1745
	protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
		// 省略部分代码···
		if (mbd != null && bean.getClass() != NullBean.class) {
			// 其实就是声明@Bean注解的时候,指定初始化方法或销毁方法是什么,在这里执行；当前实例类没有设置初始化方法，这里跳过
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}	
 
  
3.3.2.4、执行后置处理器的postProcessAfterInitialization();
 
  
	// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 432
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {
		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			// 同上，在这里接收来自Spring内部的后置处理器的洗礼（postProcessAfter）
			Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
 
  
好了，实例已经创建和初始化完毕了，接下来看看最后一步，
 
  
3.3.3、注册实现了Ordered接口的BeanPostProcessor；
 
  
代码回到 org.springframework.context.support.PostProcessorRegistrationDelegate line 233
 
  
registerBeanPostProcessors(beanFactory, internalPostProcessors);
 
  
如果到现在头还没晕，恭喜你，获得最强大脑荣誉勋章一枚！深吸一口气，马上就结束了，跟进去看看
 
  
	private static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List postProcessors) {
                // 将创建成功的BeanPostProcessor对象加入工厂,AOP核心对象创建完成
		for (BeanPostProcessor postProcessor : postProcessors) {
			beanFactory.addBeanPostProcessor(postProcessor);
		}
	}
 
  
 
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JAVA基础,Spring)

        

            

                
    
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                    
  • java 技术 架构 相关文档
                        圣心
java架构开发语言
                        
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    
                    
    • 
                    
  • SpringSecurity初学总结
                        weixin_66442229
spring
                        
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
    
                    
    • 
                    
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式
                        花儿街参考

                        
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
    
                    
    • 
                    
  • SpringBoot 设置传入参数非必要
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
    
                    
    • 
                    
  • SpringBoot 获取 ApplicationContext
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
    
                    
    • 
                                
  • 异常的核心类Throwable
                                    无量
java源码异常处理exception
                                    
    java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类 里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy 
 
 
 
package com.natsu;



    
                                
    • 
                                
  • mongoDB 游标（cursor） 实现分页 迭代
                                    开窍的石头
mongodb
                                    
    上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询 
 
     如何声明一个游标 
       var mycursor = db.user.find({_id:{$lte:5}}); 
      迭代显示游标数
    
                                
    • 
                                
  • MySQL数据库INNODB 表损坏修复处理过程
                                    0624chenhong
tomcatmysql
                                    
    最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
    
                                
    • 
                                
  • 剖析如何与设计人员沟通
                                    不懂事的小屁孩
工作
                                    
    最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。 
 
那应该如何与设计人员沟通呢？ 
 
我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
    
                                
    • 
                                
  • qq空间刷评论工具
                                    换个号韩国红果果
JavaScript
                                    
    

var a=document.getElementsByClassName('textinput');
					var b=[];
					for(var m=0;m<a.length;m++){
						if(a[m].getAttribute('placeholder')!=null)
							b.push(a[m])
					}
					var l
    
                                
    • 
                                
  • S2SH整合之session
                                    灵静志远
springAOPstrutssession
                                    
    错误信息： 
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
    
                                
    • 
                                
  • xmp标签
                                    a-john
标签
                                    
    今天在处理数据的显示上遇到一个问题： 
var html = '<li><div class="pl-nr"><span class="user-name">' + user
           + '</span>' + text + '</div></li>';
ulComme
    
                                
    • 
                                
  • Ajax的常用技巧（2）---实现Web页面中的级联菜单
                                    aijuans
Ajax
                                    
    在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。 在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
    
                                
    • 
                                
  • 天-安-门，好高
                                    atongyeye
情感
                                    
        我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。 
 
    晚上躺在床上一个人想了很久，很久。 
   
    我生在农
    
                                
    • 
                                
  • android 动画
                                    百合不是茶
android透明度平移缩放旋转
                                    
    android的动画有两种  tween动画和Frame动画 
  
tween动画;,透明度,缩放,旋转,平移效果 
  
Animation   动画 
AlphaAnimation 渐变透明度 
RotateAnimation 画面旋转 
ScaleAnimation 渐变尺寸缩放 
TranslateAnimation 位置移动 
Animation
    
                                
    • 
                                
  • 查看本机网络信息的cmd脚本
                                    bijian1013
cmd
                                    
    @echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt"
@echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt"
@echo ___________________>>"%userprofile%\
    
                                
    • 
                                
  • plsql 清除登录过的用户
                                    征客丶
plsql
                                    
    tools---preferences----logon history---history  把你想要删除的删除 
 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一起进步。 
email ： binary_spac
    
                                
    • 
                                
  • 【Pig一】Pig入门
                                    bit1129
pig
                                    
    Pig安装 
1.下载pig 
  
wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz 
  
2. 解压配置环境变量 
  
   如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量 
  
expor
    
                                
    • 
                                
  • Java 线程同步几种方式
                                    BlueSkator
volatilesynchronizedThredLocalReenTranLockConcurrent
                                    
    为何要使用同步？       java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），        将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，        从而保证了该变量的唯一性和准确性。    1.同步方法&
    
                                
    • 
                                
  • StringUtils判断字符串是否为空的方法（转帖）
                                    BreakingBad
nullStringUtils“”
                                    
    转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html 
  
public static boolean isEmpty(String str)      
　　判断某字符串是否为空，为空的标准是 str== 
null  
或 str.length()== 
0    
    
                                
    • 
                                
  • 编程之美-分层遍历二叉树
                                    bylijinnan
java数据结构算法编程之美
                                    
    

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LevelTraverseBinaryTree {

    /**
     * 编程之美 分层遍历二叉树
     * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
    
                                
    • 
                                
  • jquery取值和ajax提交复习记录
                                    chengxuyuancsdn
jquery取值ajax提交
                                    
    
// 取值
	// alert($("input[name='username']").val());
	// alert($("input[name='password']").val());
	// alert($("input[name='sex']:checked").val());
	// alert($("
    
                                
    • 
                                
  • 推荐国产工作流引擎嵌入式公式语法解析器-IK Expression
                                    comsci
java应用服务器工作Excel嵌入式
                                    
    这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 
----------转帖--------------------------------------------------- 
 IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
    
                                
    • 
                                
  • 关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer
                                    daizj
spring
                                    
    1、PropertyPlaceholderConfigurer 
Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。 
 
基本的使用方法是：(1) 
 
<bean id="propertyConfigurerForWZ&q
    
                                
    • 
                                
  • 二叉树:二叉搜索树
                                    dieslrae
二叉树
                                    
        所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. 
 
tree代码: 
 

    
                                
    • 
                                
  • C语言字符串函数大全
                                    dcj3sjt126com
cfunction
                                    
    C语言字符串函数大全 
  
  
函数名: stpcpy 
功 能: 拷贝一个字符串到另一个 
用 法: char *stpcpy(char *destin, char *source); 
程序例: 
  
#include <stdio.h> 
#include <string.h> 
  
int main
    
                                
    • 
                                
  • 友盟统计页面技巧
                                    dcj3sjt126com
技巧
                                    
    在基类调用就可以了, 基类ViewController示例代码 
-(void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];

    
                                
    • 
                                
  • window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法
                                    flyvszhb
javajdk
                                    
    window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 
 
本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 
 安装jdk1.6前，执行java -version得到 
C:\Users\liuxiang2>java -version 
java version "1.7.0_21&quo
    
                                
    • 
                                
  • Java在创建子类对象的同时会不会创建父类对象
                                    happyqing
java创建子类对象父类对象
                                    
      
1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象， 
  
2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
    
                                
    • 
                                
  • 跟我学spring3 目录贴及电子书下载
                                    jinnianshilongnian
spring
                                    
      
  一、《跟我学spring3》电子书下载地址： 
《跟我学spring3》  （1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf   
  
跟我学spring3系列 word原版 下载 
  
  二、
源代码下载  
最新依
    
                                
    • 
                                
  • 第12章 Ajax（上）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BI and EIM 4.0 at a glance
                                    blueoxygen
BO
                                    
    http://www.sap.com/corporate-en/press.epx?PressID=14787 
  
有机会研究下EIM家族的两个新产品~~~~ 
  
New features of the 4.0 releases of BI and EIM solutions include:  
 
  Real-time in-memory computing – 
    
                                
    • 
                                
  • Java线程中yield与join方法的区别
                                    tomcat_oracle
java
                                    
    长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 
&nb
    
                                
    • 
                                
  • android Manifest.xml选项
                                    阿尔萨斯
Manifest
                                    
    结构 
继承关系 
public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 
内部类 
 
 
 class Manifest.permission权限 
 class Manifest.permission_group权限组 
 构造函数 
 
public Manifest () 详细  androi
    
                                
    • 
                                
  • Oracle实现类split函数的方
                                    zhaoshijie
oracle
                                    
    关键字：Oracle实现类split函数的方 
项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 
 
CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); 
 
cr
    
                                
    •