Feirana
Feirana

Spring注解版-面向切面

一、AOP功能注解使用步骤

  1. 使用@EnableAspectJAutoProxy注解开启Spring的AOP功能;
  2. 使用@Aspect注解定义切面类, 使用@Before, @After, @AfterReturning, @AfterThrowing定义通知方法以及切点(可通过@Pointcut抽取公用的切入点表达式), 通知方法上第一个参数(且只能是第一个参数)可以写上JoinPoint joinPoint, Spring会自动注入连接点, 可通过连接点获取被增强方法的信息;
  3. 将被增强类和切面类都注册至IOC容器中
@Configuration
@EnableAspectJAutoProxy // 开启AOP
public class SpringAopConfig {
	@Bean // 注册切面
	public RoleAspect roleAspect() {
		return new RoleAspect();
	}
	@Bean // 注册被增强类
	public RoleServiceImpl roleServiceImpl() {
		return new RoleServiceImpl();
	}
}

@Aspect // 定义切面类 这里需要导入AspectJ的相关jar包才可以使用
public class RoleAspect {
	// 抽取公共的切入点表达式
	@Pointcut("execution(public int study.bryan.spring.service.impl.RoleServiceImpl.addRole(..))")
	public void pointcut() {
	}
	// 前置通知 被增强方法调用前, 前置通知被调用
	@Before("pointcut()")
	public void before(JoinPoint joinPoint) {	
		Object[] args = joinPoint.getArgs();		
		System.err.println("@Before....."+Arrays.toString(args));
	}	
	// 后置通知 无论被增强方法是否正常原型, 后置通知被调用
	@After(value = "pointcut()")
	public void after() {
		System.err.println("@After.....");
	}	
	// 返回通知 被增强方法正常运行返回后, 返回通知被调用 returning 指定通知方法里是哪个参数接收被增强方法的返回值
	@AfterReturning(value = "pointcut()", returning = "result")
	public void afterReturning(Object result) {	
		System.err.println("@AfterReturning....."+result);
	}
	// 异常通知 被增强方法出现异常, 异常通知被调用 throwing 指定通知方法哪个参数接收被增强方法抛出的异常
	@AfterThrowing(value = "pointcut()", throwing = "exception")
	public void afterThrowing(Exception exception) {
		System.err.println("@AfterThrowing....."+exception.getMessage());
	}
	// 还有一个环绕通知
}

// 被增强类
public class RoleServiceImpl {
	public int addRole(int i, int k) {
		int j = i/k;
		return j;
	}
}

二、@EnableAspectJAutoProxy: Spring何时注册AnnotationAwareAspectJAutoProxyCreator的Bean信息

  1. Spring通过@EnableAspectJAutoProxy注解开启AOP功能
  2. 在@EnableAspectJAutoProxy注解中被@Import注解标注, @Import中存在AspectJAutoProxyRegistrar类, 这个类实现了ImportBeanDefinitionRegistrar接口, 重写registerBeanDefinitions()方法;
  3. registerBeanDefinitions()方法中向Spring容器中注册了ID为org.springframework.aop.config.internalAutoProxyCreator,对象为AnnotationAwareAspectJAutoProxyCreator类的bean信息beanDefinition(只是注册bean信息, 还没有实例化);
  4. 在容器的refresh()方法中的invokeBeanFactoryPostProcessors(beanFactory);方法里就是处理了关于@Import注解中所导入的类, 将这些类的信息注册至容器中(放进一个Map beanDefinitionMap中)
    部分源码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
 // IOC学习部分讲解中 @Import用来向SpringIOC容器中注册Bean, AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar接口, 那么在重写的registerBeanDefinitions()就可以看出AspectJAutoProxyRegistrar向容器中注册了`ID`为`org.springframework.aop.config.internalAutoProxyCreator`,对象为`AnnotationAwareAspectJAutoProxyCreator`的类
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
	....
}

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
	/**
	 * 注册,扩展,和配置一个AspectJ的自动代理创建器
	 * Register, escalate, and configure the AspectJ auto proxy creator based on the value
	 * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing
	 * {@code @Configuration} class.
	 */
	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		// 1. 传入注册器 调用 AopConfigUtils的方法注册bean
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
		....其他源码
	}

}

public abstract class AopConfigUtils {
	// 这里定义了 自动代理创建器在容器中的ID值 常量 在注册的时候使用了
	public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
			"org.springframework.aop.config.internalAutoProxyCreator";
	.... 其他源码			
	// 2. 
	@Nullable
	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
		return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
	}
	// 3. 可以看到这里就直接放入了一个AnnotationAwareAspectJAutoProxyCreator 类
	@Nullable
	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
			BeanDefinitionRegistry registry, @Nullable Object source) {
		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
	}
	.... 其他源码
	//	4. Class cls就是上面传入的AnnotationAwareAspectJAutoProxyCreator 类
	@Nullable
	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;
		}
		// 5. 传入cls创建一个BeanDefinition 用于存储Bean的信息 这里的cls就是AnnotationAwareAspectJAutoProxyCreator 
		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
		beanDefinition.setSource(source);
		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		// 6. 最终看到调用注册方法 将AnnotationAwareAspectJAutoProxyCreator 注册至容器中, 且ID是AUTO_PROXY_CREATOR_BEAN_NAME ,也就是上面的常量
		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
		return beanDefinition;
	}
	.... 其他源码
}

三、AnnotationAwareAspectJAutoProxyCreator的继承树
从继承树看出AnnotationAwareAspectJAutoProxyCreator是一个beanPostProcessor 后置处理器, 也是一个Aware, 只要分析出AnnotationAwareAspectJAutoProxyCreator作为Bean后置处理器时被Spring在何时使用, 作为Aware时被Spring何时使用, 就能大致分析出AnnotationAwareAspectJAutoProxyCreator怎么被实例化, 怎么为其他Bean创建代理对象;
Spring注解版-面向切面_第1张图片
四、Spring怎么将AnnotationAwareAspectJAutoProxyCreator实例化:
在容器的refresh()方法中的registerBeanPostProcessors()方法里处理所有需要实例化的Bean后置处理器, 而AnnotationAwareAspectJAutoProxyCreator就是一个BeanPostProcessor, 所以AnnotationAwareAspectJAutoProxyCreator就是再此时被Spring实例化

  1. 先获取IOC容器中已经定义了的需要创建的所有BeanPostProcessor;
  2. 给beanFactory中添加别的BeanPostProcessor;
  3. 循环所有的BeanPostProcessor, 调用getBean()实例化BeanPostProcessor, 然后分离BeanPostProcessor为三类, 其中在实例化的时候, 就会调用AnnotationAwareAspectJAutoProxyCreator作为Aware接口时的setBeanFactory()方法, 调用到initBeanFactory()方法用来初始化BeanFactoryAspectJAdvisorsBuilder(Aspect通知处理构造器);
  4. 完成实例化后将BeanPostProcessor注册至BeanFactory中,a.先注册实现了PriorityOrdered接口的BeanPostProcessor; b. 再注册实现了Ordered接口的BeanPostProcessor; c. 最后注册没有实现优先级接口的BeanPostProcessor; 其中AnnotationAwareAspectJAutoProxyCreator是实现了Ordered接口的;
    部分源码:
public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		// 获取所有的需要实例化的Bean后置处理器
		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.
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		// 添加一些其他的Bean后置处理器
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
		// 将Bean后置处理器分离为三种
		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 调用getBean()实例化并初始化Bean后置处理器
				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);
			}
		}
		// 分别处理三类Bean后置处理器, 将BeanPostProcessor放进BeanFactory的List beanPostProcessors中
		// First, register the BeanPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> 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.
		List<BeanPostProcessor> 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.
		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).
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

五、AnnotationAwareAspectJAutoProxyCreator在什么时候为bean创建代理:
在容器的refresh()方法中的finishBeanFactoryInitialization(beanFactory)方法里完成对beanFanctory的初始化, 会实例化剩余的单例Bean, 观察Bean实例化的整个周期可以发现原理;

  1. 在beanFactory.preInstantiateSingletons()方法中, 获取所有需要实例化的beanDefinitionNames, 循环这些Bean信息, 调用getBean()->doGetBean()->getSingleton()->createBean()来实例化bean;
	@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}
		// 获取所有的beanDefinitionNames 已注册的BeanDefinition信息名称
		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 循环 
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					// 调用getBean()实例化Bean
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							// 调用getBean()实例化Bean
							getBean(beanName);
						}
					}
				}
				else {
					// 调用getBean()实例化Bean
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
				smartInitialize.end();
			}
		}
	}

	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
		.... 其他源码
				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 在这里实例化Bean
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// Explicitly remove instance from singleton cache: It might have been put there
							// eagerly by the creation process, to allow for circular reference resolution.
							// Also remove any beans that received a temporary reference to the bean.
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
		.... 其他源码
		
	}
  1. 在createBean()方法中,resolveBeforeInstantiation()方法尝试使用Bean后置处理器拦截先创建一个代理Bean实例返回;
    1. 在resolveBeforeInstantiation()方法中调用bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);方法尝试返回bean;
    2. 在applyBeanPostProcessorsBeforeInstantiation()方法中循环IOC容器中已注册的所有实现了InstantiationAwareBeanPostProcessor接口的Bean后置处理器, 调用这些Bean后置处理器的postProcessBeforeInstantiation()方法; 而AnnotationAwareAspectJAutoProxyCreator恰好就是实现了InstantiationAwareBeanPostProcessor接口的类, 在其父类AbstractAutoProxyCreator中重写了postProcessBeforeInstantiation()方法;
    3. 在 AbstractAutoProxyCreator.postProcessBeforeInstantiation()方法中, 需要满足一定条件后就会为需要实例化的Bean创建代理Bean;
    4. 在创建代理Bean成功之后就直接调用AbstractAutoProxyCreator.postProcessAfterInitialization()方法,继续处理代理Bean, 然后直接返回Bean, 不在对Bean进行实例化,赋值属性,初始化等生命周期里的常规处理;
@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		.....其他源码
		try {
			// 在实例化Bean之前提前拦截 尝试使用BeanPostProcessors 去创建代理Bean, 成功则直接返回代理Bean
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			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 {
			// 如果没有创建代理Bean, 则调用doCreateBean()去实例化Bean
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			// A previously detected exception with proper bean creation context already,
			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
			throw ex;
		}
		.....其他源码
	}

	@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					// 调用applyBeanPostProcessorsBeforeInstantiation(), 这里面就调用了postProcessBeforeInstantiation()方法
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					// 如果Bean被实例化成功 则直接调用Bean后置处理器的BeanPostProcessorsAfterInitialization()方法
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}
	
	@Nullable
	protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			// 循环所有的InstantiationAwareBeanPostProcessor, 调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation();
			// 如果当前InstantiationAwareBeanPostProcessor刚好是AnnotationAwareAspectJAutoProxyCreator, 那么就会调用其父类 `AbstractAutoProxyCreator.postProcessBeforeInstantiation()`的方法去尝试创建代理Bean
			Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
			if (result != null) {
				return result;
			}
		}
		return null;
	}
  1. 如果resolveBeforeInstantiation()没有成功创建代理Bean, 则调用doCreateBean()真正实例化(调用Bean的构造器实例化)bean[createBeanInstance()],给bean属性赋值[populateBean()], 初始化bean[initializeBean()];
    1. initializeBean()方法中, 调用applyBeanPostProcessorsBeforeInitialization(), 在此方法中循环所有的Bean后置处理器, 调用Bean后置处理器的postProcessBeforeInitialization()方法;
    2. 接着调用invokeInitMethods()方法, 此方法中如果bean实现了InitializingBean接口,则调用bean重写的afterPropertiesSet()方法, 如果init-method属性指定了bean的初始化方法那么接着回调bean的初始化方法;
    3. 接着调用applyBeanPostProcessorsAfterInitialization()方法,此方法中循环所有Bean后置处理器, 调用Bean后置处理器的postProcessAfterInitialization()方法;而AnnotationAwareAspectJAutoProxyCreator的父类AbstractAutoProxyCreator实现了BeanPostProcessor的postProcessAfterInitialization();Spring在AbstractAutoProxyCreator.postProcessAfterInitialization()方法中为需要实例化的Bean创建代理Bean;
	// 实例化Bean的方法
	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 在这里首次调用Bean构造器实例化Bean
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		.....其他源码....

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			// 为Bean的属性赋值
			populateBean(beanName, mbd, instanceWrapper);
			// 初始化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);
			}
		}
		.....其他源码....
		return exposedObject;
	}

	// 初始化Bean的方法
	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			// 如果Bean实现了Aware接口, 这里就会回调重写Aware接口的某些方法, 为Bean赋值一些Spring底层的组件
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			// 调用Bean后置处理器的BeanPostProcessorsBeforeInitialization()方法 处理Bean
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
		    // 回调Bean的初始化方法 如果Bean实现了`InitializingBean`接口,则调用`bean`重写的`afterPropertiesSet()`方法, 如果`init-method`属性指定了`bean`的初始化方法那么接着回调`bean`的初始化方法
			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()) {
			// 调用Bean后置处理器的BeanPostProcessorsAfterInitialization()方法 处理Bean
			// 在这里AnnotationAwareAspectJAutoProxyCreator的父类AbstractAutoProxyCreator重写了BeanPostProcessor的BeanPostProcessorsAfterInitialization(), 在重写的方法里为Bean创建了代理Bean
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

综上所述: AnnotationAwareAspectJAutoProxyCreator在Spring调用doCreateBean()方法将Bean实例化之前就拦截一次, 调用AbstractAutoProxyCreator.postProcessBeforeInstantiation()尝试创建代理Bean; 如果没有创建成功, 则在Bean实例化,属性复制, 初始化之后,调用AbstractAutoProxyCreator.postProcessAfterInitialization()方法创建代理Bean;

六、AnnotationAwareAspectJAutoProxyCreator如何为bean创建代理:
已知Spring会在Bean实例化之前调用AbstractAutoProxyCreator.postProcessBeforeInstantiation()尝试创建代理Bean, 已经在初始化后调用AbstractAutoProxyCreator.postProcessAfterInitialization()方法创建代理Bean, 那么分析这两个方法中是如何处理的, 就能知道Spring是如何为Bean创建代理Bean;

  1. AbstractAutoProxyCreator.postProcessBeforeInstantiation()方法分析:
    1. 判断当前Bean是否已经在 advisedBeans(存放了所有被增强的代理Bean)中, 如果存在就返回null;
    2. 判断当前Bean是否实现了Advice,Pointcut,Advisor,AopInfrastructureBean接口或者是否被@Aspect注解标注, 如果是则表示当前Bean是一个切面类, 那就返回Null;
    3. 判断是否应该跳过: 先获取容器中所有的通知Advisor, 如果这些通知存在一个是AspectJPointcutAdvisor, 那么需要跳过, 方法返回Null;
    4. 获取一个自定义的TargetSource, 如果TargetSource存在, 则通过TargetSource创建代理Bean;
@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
		Object cacheKey = getCacheKey(beanClass, beanName);

		if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
			if (this.advisedBeans.containsKey(cacheKey)) {
				return null;
			}
			if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
				this.advisedBeans.put(cacheKey, Boolean.FALSE);
				return null;
			}
		}

		// Create proxy here if we have a custom TargetSource.
		// Suppresses unnecessary default instantiation of the target bean:
		// The TargetSource will handle target instances in a custom fashion.
		TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
		if (targetSource != null) {
			if (StringUtils.hasLength(beanName)) {
				this.targetSourcedBeans.add(beanName);
			}
			Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
			Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		return null;
	}
  1. AbstractAutoProxyCreator.postProcessAfterInitialization()方法分析:
    1. 调用wrapIfNecessary()方法, 包装Bean;
    2. 在wrapIfNecessary()中, 先按postProcessBeforeInstantiation()方法前三点一样判断, 满足条件后往下走
    3. 获取符合当前Bean的所有增强器(通知方法)AdvisorsForBean: 也就是通过切入点表达式去匹配, 获取能够符合当前Bean的通知方法;
    4. 如果能够获取到符合当前Bean的增强器, 那么将当前Bean存入advisedBeans中, 标志已增强;然后调用createProxy()方法创建代理Bean;
    5. 在createProxy()方法中利用ProxyFactory 代理工厂创建代理Bean, 先将符合Bean的增强器Advisors注入至ProxyFactory , 然后调用proxyFactory.getProxy(getProxyClassLoader())方法;
    6. proxyFactory.getProxy()方法中先调用createAopProxy()方法根据规则返回一个AopProxy接口的代理工厂对象, 可能是CglibAopProxy,也可能是JdkDynamicAopProxy, 然后调用AopProxy接口的getProxy()方法为当前Bean创建代理对象, 最终给容器返回被增强后的代理对象;
    7. 之后在容器中获取Bean时, 容器返回的就是被增强后的代理Bean;
	@Override
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}

	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}
		// 获取符合当前Bean的增强器, 根据切入点表达式去匹配
		// Create proxy if we have advice.
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		// 如果存在增强器, 则创建代理对象, 如果不存在增强器, 则不创建直接放回Bean
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}
	
	// 创建代理对象
	protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {

		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}

		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);

		if (!proxyFactory.isProxyTargetClass()) {
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
		// 获取符合当前Bean的增强器
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		// 将增强器注入代理工厂
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);

		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}
		// 创建代理工厂对象, 调用getProxy()创建代理Bean
		return proxyFactory.getProxy(getProxyClassLoader());
	}

	// 这段代码决定Spring是使用Cglib还是JDK来为Bean创建动态代理
	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		if (!IN_NATIVE_IMAGE &&
				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			// 当前Bean是一个接口或者当前Bean继承了JDK的Proxy的动态代理,那么Spring就会选择适用JDK动态代理
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

七、增强器(通知方法)如何拦截代理对象的目标方法的执行:
已知Spring开启AOP功能之后,会为需要需要增强的Bean实例化一个代理对象, 之后每次从容器中获取Bean时,拿到的都是代理对象, 使用代理对象执行目标方法时, Spring会根据按照一定顺序执行通知方法;那么Spring是如何实现的拦截目标方法执行前后来执行通知方法的呢?

  1. 从容器中获取Bean, 可以发现容器返回是一个Cglib代理生成的代理对象
    Spring注解版-面向切面_第2张图片

  2. 当执行目标方法时, 会被CglibAopProxy&DynamicAdvisedInterceptor.intercept()方法拦截;

  3. 首先拦截方法中会根据目标对象和目标方法获取 拦截器链 List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 实际上这部分操作是将目标方法的所有增强器(通知方法)封装成MethodInterceptor集合

  4. 如果没有拦截器链, 则直接执行目标方法

  5. 如果有拦截器链, 则需要创建一个CglibMethodInvocation对象, 并调用CglibMethodInvocation.proceed()方法

    1. 通过proceed()方法触发所有通知方法和目标方法的调用
    2. 在proceed()方法中 有一个常量this.currentInterceptorIndex 用来代表当前拦截器链索引, 默认为-1,每次进入proceed()方法时this.currentInterceptorIndex都自增一次, 通过索引在之前封装的chain 中获取拦截器(其实就是增强器), 获取到拦截器后, 调用拦截器的invoke()方法, 在每个拦截器的invoke()方法中回调proceed(),且处理回调相关的通知方法;
    3. 当this.currentInterceptorIndex的值等于chain的长度-1时, 表示已经循环到最后的连接器链, 此时回调目标方法, 将目标方法的返回值返回;然后依次返回前一次调用的方法;

  6. 流程图:
    Spring注解版-面向切面_第3张图片

    7. 综上所述: SpringAOP通过CglibAopProxy来拦截目标方法的, 获取目标方法的所有增强器(通知方法), 将通知方法按一定顺序封装成MethodInterceptor(方法拦截器)集合, 形成一个拦截器链; 根据目标对象目标方法以及获取的拦截器链创建CglibMethodInvocation对象, 调用CglibMethodInvocation.proceed()方法, 类似递归一样,循环获取拦截器链来处理回调通知方法; 达到在目标方法前后能够执行各种通知方法的目的

    你可能感兴趣的:(Spring,spring,aop)

    • 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做一
    • 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，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    • 深入理解AOP（面向切面编程）及其应用 自身就是太阳 java开发语言spring
      目录AOP的核心概念AOP的实现方式1.定义DAO接口和实现类2.定义通知类3.开启AOP注解驱动切入点表达式通配符的使用：AOP通知类型案例分析：测量业务层接口的执行效率结论概述：AOP（Aspect-OrientedProgramming，面向切面编程）是一种编程范式，主要用于将共性功能从具体的业务逻辑中分离出来，实现松耦合的代码设计。其作用是在不修改原始代码的情况下，对现有方法进行增强，广泛
    • 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
    • 用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类） AdyZhang POJOeclipseHibernateMiddleGenIDE
      推荐:MiddlegenIDE插件,   是一个Eclipse   插件.     用它可以直接连接到数据库,   根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件!     今天开始试着使用
    • .9.png Cb123456 android
        “点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png 　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。 　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
    • 算法的效率 天子之骄 算法效率复杂度最坏情况运行时间大O阶平均情况运行时间
      算法的效率 效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。   以下是我的学习笔记：   1.求值与霍纳法则，即为秦九韶公式。   2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。
    • java数据结构 何必如此 java数据结构
      Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类： 枚举（Enumeration） 位集合（BitSet） 向量（Vector） 栈（Stack） 字典（Dictionary） 哈希表（Hashtable） 属性（Properties） 以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
    • MybatisHelloWorld 3213213333332132
      //测试入口TestMyBatis package com.base.helloworld.test; import java.io.IOException; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibat
    • Java|urlrewrite|URL重写|多个参数 7454103 javaxmlWeb工作
       个人工作经验！ 如有不当之处，敬请指点 1.0  web -info 目录下建立     urlrewrite.xml  文件 类似如下： <?xml version="1.0" encoding="UTF-8" ?>   <!DOCTYPE u
    • 达梦数据库+ibatis darkranger sqlmysqlibatisSQL Server
      --插入数据方面 如果您需要数据库自增... 那么在插入的时候不需要指定自增列. 如果想自己指定ID列的值, 那么要设置 set identity_insert  数据库名.模式名.表名; ----然后插入数据; example: create table zhabei.test( id bigint identity(1,1) primary key, nam
    • XML 解析 四种方式 aijuans android
      XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。 XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object
    • spring中配置文件占位符的使用 avords
      1.类 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
    • 前端工程化-公共模块的依赖和常用的工作流 bee1314 webpack
      题记： 一个人的项目，还有工程化的问题嘛？   我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？ 你真的想这样嘛？   var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。  
    • 上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？ bijian1013 项目管理沟通IT职业规划
      问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应         正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。   Eno-Bea回答，注重感受，不一定是别人的         虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
    • TortoiseSVN，过滤文件 征客丶 SVN
      环境： TortoiseSVN 1.8 配置： 在文件夹空白处右键 选择  TortoiseSVN -> Settings 在 Global ignote pattern 中添加要过滤的文件： 多类型用英文空格分开 *name ： 过滤所有名称为 name 的文件或文件夹 *.name ： 过滤所有后缀为 name 的文件或文件夹 --------
    • 【Flume二】HDFS sink细说 bit1129 Flume
      1. Flume配置   a1.sources=r1 a1.channels=c1 a1.sinks=k1 ###Flume负责启动44444端口 a1.sources.r1.type=avro a1.sources.r1.bind=0.0.0.0 a1.sources.r1.port=44444 a1.sources.r1.chan
    • The Eight Myths of Erlang Performance bookjovi erlang
      erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide 里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html   Myth: Funs are sl
    • java多线程网络传输文件(非同步)-2008-08-17 ljy325 java多线程socket
      利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。 使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer. 客户端: 修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
    • 读《研磨设计模式》-代码笔记-模板方法模式 bylijinnan java设计模式
      声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet;
    • 配置心得 chenyu19891124 配置
      时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。 作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。 做了一年的配置管理给自总结下： 1.改变 从一个以前对配置毫无
    • 对“带条件选择的并行汇聚路由问题”的再思考 comsci 算法工作软件测试嵌入式领域模型
      2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
    • Oracle 10g 的clusterware 32位 下载地址 daizj oracle
      Oracle 10g 的clusterware 32位 下载地址 http://pan.baidu.com/share/link?shareid=531580&uk=421021908 http://pan.baidu.com/share/link?shareid=137223&uk=321552738 http://pan.baidu.com/share/l
    • 非常好的介绍：Linux定时执行工具cron dongwei_6688 linux
      Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。 新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
    • Yii assets目录生成及修改 dcj3sjt126com yii
      assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。 assets设置对应的方法位置 \framework\web\CAssetManager.php   assets配置方法 在m
    • mac工作软件推荐 dcj3sjt126com mac
      mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。 我为什么要要iterm2 切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点： * 兼容性好，远程服务器 vi 什么的低版本能很好兼
    • Memcached(三)、封装Memcached和Ehcache frank1234 memcachedehcachespring ioc
      本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。 cache.xml <?xml version="1.0" encoding="UTF-8"?>
    • Remove Duplicates from Sorted List II hcx2013 remove
      Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5,
    • Spring4新特性——注解、脚本、任务、MVC等其他特性改进 jinnianshilongnian spring4
      Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
    • MySQL安装文档 liyong0802 mysql
        工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。   安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。   Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
    • 使用VS2010构建HotSpot工程 p2p2500 HotSpotOpenJDKVS2010
      1. 下载OpenJDK7的源码：      http://download.java.net/openjdk/jdk7      http://download.java.net/openjdk/      2. 环境配置     ▶
    • Oracle实用功能之分组后列合并 seandeng888 oracle分组实用功能合并
      1       实例解析 由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下： 表test 数据如下： ID,SUBJECTCODE,DIMCODE,VALUE 1&nbs
    • Java定时任务注解方式实现 tuoni javaspringjvmxmljni
      Spring 注解的定时任务，有如下两种方式： 第一种： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"  xmlns:xsi="http
    • 11大Java开源中文分词器的使用方法和分词效果对比 yangshangchuan word分词器ansj分词器Stanford分词器FudanNLP分词器HanLP分词器
      本文的目标有两个： 1、学会使用11大Java开源中文分词器 2、对比分析11大Java开源中文分词器的分词效果 本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。 11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： /** * 获取文本的所有分词结果, 对比