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)

    • SpringMVC设置全局异常处理器 水岸齐天 javaspring
      文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
    • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
      packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
    • springboot集成logback-spring.xml文件 RT_0114 SpringBootspringbootspringlogback
      彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
    • eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature zhangfeng1133 ideeclipsejava
      报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
    • linux安装docker及docker-compose 部署spring boot项目 时而有事儿 dockerlinuxdockerlinuxspringboot
      linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
    • Websocket服务监听收发消息 beiback Java服务器问题websocket网络协议网络
      目录1.pom依赖坐标2.项目配置端口和项目包名2.创建处理器3.注册处理器4.前端页面1.pom依赖坐标org.springframework.bootspring-boot-starter-websocket2.项目配置端口和项目包名application.propertiesserver.port=8088//路径规范：为应用的所有servlet提供一个统一的前缀，使URL结构更加清晰和一致
    • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java 计算机程序老哥
      作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
    • 使用Spring Boot Admin监控和管理Spring Boot应用程序 岚珂瓜呱 springbootspringboot后端javaspringmybatis数据库
      使用SpringBootAdmin监控和管理SpringBoot应用程序SpringBootAdmin是一个用于监控和管理SpringBoot应用程序的开源工具。它提供了一个直观的用户界面，用于查看应用程序的健康状态、详细信息、日志等，并支持一些管理功能。下面是一个简单的示例，演示如何在SpringBoot应用程序中集成SpringBootAdmin：添加SpringBootAdmin依赖：首先，
    • 使用Spring Security进行LDAP（轻量目录访问协议）认证 岚珂瓜呱 springbootspringjava数据库后端开发语言springboot
      使用SpringSecurity进行LDAP（轻量目录访问协议）认证使用SpringSecurity进行LDAP认证非常简单，您只需配置SpringSecurity以连接到LDAP服务器并执行认证即可。以下是一个简单的示例，演示如何在SpringBoot应用程序中实现LDAP认证：添加SpringSecurity和SpringLDAP依赖：首先，您需要添加SpringSecurity和Spring
    • 论文整理：隐私签名 yixvxi Survey文档资料学习
      最近准备开题了（苦恼…），整理一些看过/没看过的论文。持续更新…数字签名：隐私数字签名的定义&安全性(book)0.Deffie-Hellman.NewDirectionsinCryptography.1976Katz,J.(2010).DigitalSignatures:BackgroundandDefinitions.In:DigitalSignatures.Springer,Boston,M
    • 配置 IDEA 远程连接应用服务器 O_Neal
      当调试Web应用时，经常需要使用ide远程连接，来进行debug调试。使用Springboot内置服务器和使用Tomcat服务器是常见的应用部署方式，可以用不同的配置方式来启动远程debug模式。Springboot应用1.配置启动参数运行jar时加上debug参数，例如java-jar-Xdebug-Xrunjdwp:transport=dt_socket,address=60222,suspe
    • spring security 权限(注解) LaoCat__ javaspringcloudweb后端javaspringbootspringsecurity
      写在前边整理的知识点都是从其他博客中来，如有侵权，立删！参考:https://blog.csdn.net/qq_32867467/article/details/103097190正题:SpringSecurity默认是禁用注解的，要想开启注解，要在继承WebSecurityConfigurerAdapter的类加@EnableMethodSecurity注解，并在该类中将Authenticati
    • spring cloud gateway k8s优雅启停 luffy_1993 kubernetes容器云原生
      通过配置readiness探针和preStophook，实现优雅启动和停止（滚动部署）1.k8s工作负载配置readinessProbe:httpGet:path:/datetimeport:8080scheme:HTTPinitialDelaySeconds:30timeoutSeconds:1periodSeconds:30successThreshold:1failureThreshold:
    • Websocket + Vue使用 人间观察师 websocketvue.js前端
      这里有一篇文档可以参考一下>闪现POM文件org.springframework.bootspring-boot-starter-websocket2.7.0WebSocketConfig配置importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configura
    • [套路] 浏览器引入Vue.js场景-WangEditor富文本编辑器的使用 (永久免费) Grandpa_Rick 套路frontendvue.js前端javascriptwangEditor
      系列文章目录[套路]el-table多选属性实现单选效果[套路]基于服务内存实现的中文拼音混合查询[套路]Bypass滑块验证码目录系列文章目录前言一、实现1.1场景1.2Window对象简介1.3引入WangEditor1.4页面配置前言公司使用freemarker的老旧SpringBootWeb后台项目,前两年通过浏览器引入js的方式使用Vue简单升级了下,方便迭代功能.近期一个很简单的功能需
    • spring boot高级运用：使用Spring Cloud Config实现集中式配置管理，动态管理应用程序配置 岚珂瓜呱 springbootspringboot后端java开发语言spring
      使用SpringCloudConfig实现集中式配置管理，动态管理应用程序配置使用SpringCloudConfig实现集中式配置管理非常强大，它允许您将应用程序的配置从代码中分离出来，并集中存储在一个或多个配置存储库中（例如Git，SVN等）。下面是一个简单的示例，演示如何使用SpringCloudConfig来实现这一点：创建配置存储库：在您的版本控制系统（例如Git）中创建一个配置存储库，用
    • springboot项目学习-瑞吉外卖（1） 两仪式quq springboot学习java瑞吉外卖
      第一天任务如下：建立基本架构完成登录、退出功能注意：本博客没有使用网上教程里的mybatis-plus，使用的是mybatis；数据库连接池也没有使用教程里的druid，使用的是spring自带的连接池基本架构common包：存放的通用类R，用来给前端返回Json格式的数据config包：存放配置类，在今天的任务中主要解决静态资源路径映射问题controller包entity包：存放实体类mapp
    • springboot中get post put delete 请求区别详解 developerFBI JAVASpringbootjava
      Spring4.3中引进了｛@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PatchMapping｝来帮助简化常用的HTTP方法的映射并更好地表达被注解方法的语义。1.@GetMapping：处理get请求，传统的RequestMapping来编写应该是@RequestMapping(value=“/get/{id}”,method=Re
    • docker-ce安装 蚁景网络安全 dockereureka容器
      安装docker-ce使用清华镜像源加速安装docker-ce原文：docker-ce|镜像站使用帮助|清华大学开源软件镜像站|TsinghuaOpenSourceMirror#方法一exportDOWNLOAD_URL="https://mirrors.tuna.tsinghua.edu.cn/docker-ce"#如果使用curl，执行如下命令curl-fsSLhttps://get.dock
    • 第10讲_Spring对Dao的支持 吴国友
      Spring框架优秀就是在于MVC开发的时候一旦需要对底层的数据库操作，它可以很好的支持JDBC技术，还有现在主流的ORM框架（Hibernate,MyBatis）技术。重点先介绍Spring对JDBC支持。在Spring对JDBC支持中提供了一个模板JdbcTemplate，此模板封装了对JDBC操作的许多方法，且消除了忽视资源释放而引起的漏洞Spring对JDBC操作需要导入的jar（开发环境
    • 05. spring-boot对spring-mvc的自动配置 马晓钧
      spring-mvc的自动配置viewResolver：视图解析器：根据方法的返回值得到视图对象(View)。//会将容器中已有的ViewResolver和自己定义的ViewResolver全部add进去ContentNegotiatingViewResolver自定义视图解析器：//需要实现ViewResolver，并注入进容器@ConfigurationpublicclassViewConfi
    • rabbitmq发送json消息 陌以然I rabbitmqjava分布式
      rabbitmq发送json格式消息packageorg.secp.rabbitmq.exchange;importorg.springframework.amqp.core.Binding;importorg.springframework.amqp.core.BindingBuilder;importorg.springframework.amqp.core.Queue;importorg.s
    • 【Elasticsearch】从零开始搭建ES8集群并且集成到Springboot，更好的服务电商类等需要全文索引的项目（一） Smily清禾酥酒 中间件elasticsearchspringbootlucenejava全文检索
      从零开始搭建Elasticsearch集群（一）从零开始搭建Elasticsearch8.6集群（一）简单介绍下Elasticsearch，以及为何使用它下载Elasticsearch准备服务器解压安装配置文件elasticsearch.yml修改调整JVM运行内存设置密码证书认证1.生成证书2.生成秘钥3.迁移凭证地址到config目录下4.其他集群都要将这个凭证移动到这个ES安装的config
    • JdkDynamicAopProxy学习 weixin_44877172 Spring学习javaspring
      简介JdkDynamicAopProxy#invoke是SpringAOP（面向切面编程）框架中用于动态代理的核心方法之一。这个方法是在使用JDK动态代理时，通过JdkDynamicAopProxy类创建的代理对象上调用目标方法时，被自动调用的。以下是该方法的解析：方法签名首先，我们先看一下invoke方法的签名：publicObjectinvoke(Objectproxy,Methodmetho
    • 某小厂java后端初面，记录一下 bpmh Java开发1天1道面试题java面试
      好吧，，，，，本人很菜，再接再励吧，继续刷。简单记录一下面试题，未亡羊补牢呗。1.liftjoin;innerjoin;rightjoin的区别2.union和unionall的区别3.like查询会走索引吗？4.主键和索引的区别5.count(*),count(1),count(ID)的区别6.exists了解吗？作用是什么7.线程池了解吗？8.spring创建的bean是单例模式还是多例模式，
    • Vue+SpringBoot打造数据可视化的智慧河南大屏 桑程程 信息可视化vue.jsspringboot前端javascript后端springcloud
      目录一、摘要1.1项目介绍1.2项目录屏二、功能模块三、系统展示四、核心代码4.1数据模块A4.2数据模块B4.3数据模块C4.4数据模块D4.5数据模块E五、免责说明一、摘要1.1项目介绍基于JAVA+Vue+SpringBoot+MySQL的数据可视化的智慧河南大屏，包含了GDP、人口、土地面积、企业数、人均收入数据排行、地图展示等模块，还包含系统自带的用户管理、部门管理、角色管理、菜单管理、
    • spring boot 验证码源代码，直接复制使用 古猿写代码 springbootspringbootjava前端
      使用springboot实现验证码源代码，直接复制使用publicvoidgetCodeImage(HttpServletResponseresponse){//随机生成4位验证码RandomGeneratorrandomGenerator=newRandomGenerator("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVW
    • 如何在Spring Boot应用中高效集成Spring Cache与Redis实现高性能缓存机制 yangqjiayou spring缓存springboot
      一、引言在现代Web应用程序开发中，缓存是一种常见的优化手段，能够显著提升系统性能，减轻数据库负载。SpringCache作为Spring框架内建的缓存抽象层，提供了一种简单易用的方式来统一处理缓存逻辑。而Redis作为一种高性能的内存键值存储系统，经常被选作SpringCache的后端存储。本文将通过一个真实的项目实例，详细介绍SpringCache的使用方法及其与Redis的集成过程。二、Sp
    • @SpringBootApplication ：简化 Spring Boot 项目的配置和初始化过程 wddblog javaspringbootspringboot后端java
      @SpringBootApplication是SpringBoot框架中的一个核心注解，它用于简化SpringBoot项目的配置和初始化过程。通过使用该注解，开发者可以快速地创建一个独立、可执行的Spring应用程序，而无需编写大量的配置代码。一、@SpringBootApplication的基本概念@SpringBootApplication是一个复合注解，它实际上包含了三个关键的注解：@Spr
    • SpringData JPA 数据表映射 路面烧卖 从零开始学SpringDataJPAjavahibernatespring
      SpringDataJPA数据表映射1、映射注解说明1.配置多表联系注解介绍@OneToOne一对一映射targetEntityClass：指定另一方类的字节码cascade：级联操作CascadeType.MERGE级联更新CascadeType.PERSIST级联保存CascadeType.REFRESH级联刷新CascadeType.REMOVE级联删除CascadeType.ALL级联上述
    • 用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开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： /** * 获取文本的所有分词结果, 对比