spring源码分析08-springAOP底层源码解析

最新推荐文章于 2023-02-17 10:39:38 发布
最新推荐文章于 2023-02-17 10:39:38 发布
阅读量174 收藏
点赞数
分类专栏： spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d495435207/article/details/128476325
版权

springAOP代理流程图

在这里插入图片描述

1.动态代理

代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对 程序进行扩展。

比如，现在存在一个TestService 类：

public class TestService {
	public String test(String pre){
		System.out.println(this.getClass().getName()+","+pre+":running!");
		return "hello:"+pre;
	}
}

此时，我们new一个TestService 对象，然后执行test()方法，结果是显而易见的。 如果我们现在想在不修改UserService类的源码前提下，给test()增加额外逻辑，那么就可以使用动态 代理机制来创建TestService对象了。
比如：

//被代理对象
		TestService testService = new TestService();
		// 在不修改TestService的情况下。给test（）方法增加额外的逻辑。那么就可以使用动态代理机制来实现
		//CGlib代理
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(TestService.class);
		enhancer.setCallbacks(new Callback[]{ new MethodInterceptor() {
			@Override
			public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
				System.out.println(method.getName()+",before");
				Object invoke = method.invoke(testService, objects);
				System.out.println(method.getName()+",after");
				return invoke;
			}
		}, NoOp.INSTANCE}); // NoOp.INSTANCE 默认为空的方法拦截器
		enhancer.setCallbackFilter(new CallbackFilter() {
			@Override
			public int accept(Method method) {
				if(method.getName().equals("test"))
					return 0;  // 下标为0的方法拦截器
				else
					return 1; // 下标为1 的方法拦截器 NoOp.INSTANCE
			}
		});

		//代理对象
		TestService proxyTestService = (TestService) enhancer.create();
		System.out.println(proxyTestService.test("_world_"));

得到的都是TestService对象，但是执行test()方法时的效果却不一样了，这就是代理所带来的效果。
上面是通过cglib来实现的代理对象的创建，是基于父子类的，被代理类（TestService）是父类，代理类是子类，代理对象就是代理类的实例对象，代理类是由cglib创建的，对于程序员来说不用关心。

除开cglib技术，jdk本身也提供了一种创建代理对象的动态代理机制，但是它只能代理接口，也就是 UserService得先有一个接口才能利用jdk动态代理机制来生成一个代理对象，比如：


public interface TestServiceInterface {
	String test(String pre);
}

public class TestService implements TestServiceInterface{
	public String test(String pre){
		System.out.println(this.getClass().getName()+","+pre+":running!");
		return "hello:"+pre;
	}

	public String aa(String pre){
		System.out.println(this.getClass().getName()+","+pre+":running!");
		return "hello:"+pre;
	}
}

//被代理对象
		TestService testService = new TestService();
//JDK代理
		//代理对象需要有父接口。只能接口代理。
		Object o = Proxy.newProxyInstance(AOPTest.class.getClassLoader(), new Class[]{TestServiceInterface.class}, new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

				System.out.println(method.getName() + ",before");
				Object invoke = method.invoke(testService, args);
				System.out.println(method.getName() + ",after");
				return invoke;
			}
		});
		TestServiceInterface testServiceInterface = (TestServiceInterface) o;
		System.out.println(testServiceInterface.test("mamaipi_"));

由于这个限制，所以产生的代理对象的类型是TestServiceInterface，而不是TestService ，这是需要注意的。

2.ProxyFactory

上面我们介绍了两种动态代理技术，那么在Spring中进行了封装，封装出来的类叫做ProxyFactory， 表示是创建代理对象的一个工厂，使用起来会比上面的更加方便，比如：

//spring 动态代理
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.setTarget(testService);
		// 前置增强
		proxyFactory.addAdvice(new MethodBeforeAdvice() {
			@Override
			public void before(Method method, Object[] args, Object target) throws Throwable {
				System.out.println("spring_proxy:before");
			}
		});

		proxyFactory.addAdvice(new org.aopalliance.intercept.MethodInterceptor() {
			@Nullable
			@Override
			public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
				System.out.println("_around_");
				return invocation.proceed();   // 如果不执行 后续 aop也无法执行
			}
		});

	TestService proxy = (TestService) proxyFactory.getProxy();
		System.out.println(proxy.aa("_mamaipipipi_"));

通过ProxyFactory，我们可以不再关系到底是用cglib还是jdk动态代理了，ProxyFactory会帮我们去判断，如果UserService实现了接口，那么ProxyFactory底层就会用jdk动态代理，如果没有实现接口，就会用cglib技术

Advice的分类:

  1. Before Advice：方法之前执行
public class HzgBeforeAdvice implements MethodBeforeAdvice {

	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("方法执行前执行");
	}
}
  1. After returning advice：方法return后执行
public class HzgAfterReturningAdvice implements AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		System.out.println("方法return后执行");
	}
}
  1. After throwing advice：方法抛异常后执行
public class HzgThrowsAdvice implements ThrowsAdvice {

	public void afterThrowing(Method method, Object[] args, Object target, NullPointerException ex) {
		System.out.println("方法抛出异常后执行");
	}

}
  1. After (finally) advice：方法执行完finally之后执行，这是最后的，比return更后
public class HzgAfterReturningAdvice implements AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		System.out.println("方法return后执行");
	}
}
  1. Around advice：这是功能最强大的Advice，可以自定义执行顺序
public class HzgAroundAdvice implements MethodInterceptor {

	@Nullable
	@Override
	public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
		System.out.println("方法执行Around前");
		Object proceed = invocation.proceed();
		System.out.println("方法执行Around后");
		return proceed;
	}
}

Advisor的理解
跟Advice类似的还有一个Advisor的概念，一个Advisor是有一个Pointcut和一个Advice组成的，通过Pointcut可以指定要需要被代理的逻辑，比如一个UserService类中有两个方法，按上面的例子， 这两个方法都会被代理，被增强，那么我们现在可以通过Advisor，来控制到具体代理哪一个方法， 比如

//spring 动态代理
//被代理对象
TestService testService = new TestService();
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(testService);
proxyFactory.addAdvisor(new PointcutAdvisor() {
			@Override
			public Pointcut getPointcut() {  // 切点。 可以匹配具体方法
				return new StaticMethodMatcherPointcut() {
					@Override
					public boolean matches(Method method, Class<?> targetClass) {
						return method.getName().equals("test");
					}
				};
			}

			@Override
			public Advice getAdvice() {
				return new org.aopalliance.intercept.MethodInterceptor() {
					@Nullable
					@Override
					public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
						System.out.println("proxy_factory:getAdvice:begin");
						Object proceed = invocation.proceed();
						System.out.println("proxy_factory:getAdvice:end");
						return proceed;
					}
				};
			}
TestService proxy = (TestService) proxyFactory.getProxy();
		System.out.println(proxy.aa("_mamaipipipi_"));

上面代码表示，产生的代理对象，只有在执行test这个方法时才会被增强，会执行额外的逻辑， 而在执行其他方法时是不会增强的。

3.spring中创建代理对象的方式

上面介绍了Spring中所提供了ProxyFactory、Advisor、Advice、PointCut等技术来实现代理对象的创建，但是我们在使用Spring时，我们并不会直接这么去使用ProxyFactory，比如说，我们希望 ProxyFactory所产生的代理对象能直接就是Bean，能直接从Spring容器中得到TestService的代理对象，而这些，Spring都是支持的，只不过，作为开发者的我们肯定得告诉Spring，那些类需要被代理，代理逻辑是什么。

3.1 ProxyFactoryBean 创建代理对象

@Bean
	public ProxyFactoryBean userServiceProxy() {
		UserService userService = new UserService();
		ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
		proxyFactoryBean.setTarget(userService);
		proxyFactoryBean.addAdvice(new MethodInterceptor() {
			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("before...");
				Object result = invocation.proceed();
				System.out.println("after...");
				return result;
			}
		});
		return proxyFactoryBean;
	}

通过这种方法来定义一个UserService的Bean，并且是经过了AOP的。但是这种方式只能针对某一个 Bean。它是一个FactoryBean，所以利用的就是FactoryBean技术，间接的将UserService的代理对象作为了Bean。

ProxyFactoryBean还有额外的功能，比如可以把某个Advise或Advisor定义成为Bean，然后在 ProxyFactoryBean中进行设置

@Bean
public MethodInterceptor hzgAroundAdvise(){
	return new MethodInterceptor() {
		@Nullable
		@Override
		public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
			System.out.println("hzgAroundAdvise:before");
			Object proceed = invocation.proceed();
			System.out.println("hzgAroundAdvise:after");
			return proceed;
		}
	};
}

@Bean
public ProxyFactoryBean userService(){
	UserService userService = new UserService();
	ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
	proxyFactoryBean.setTarget(userService);
	proxyFactoryBean.setInterceptorNames("hzgAroundAdvise");
	return proxyFactoryBean;
}

3.2 BeanNameAutoProxyCreator 创建代理对象

ProxyFactoryBean得自己指定被代理的对象，那么我们可以通过BeanNameAutoProxyCreator来通 过指定某个bean的名字，来对该bean进行代理

@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator(){
	BeanNameAutoProxyCreator proxyCreator = new BeanNameAutoProxyCreator();
	proxyCreator.setBeanNames("userS*");
	proxyCreator.setInterceptorNames("hzgAroundAdvise");
	proxyCreator.setProxyTargetClass(true);
	return proxyCreator;
}

通过BeanNameAutoProxyCreator可以对批量的Bean进行AOP，并且指定了代理逻辑，指定了一个 InterceptorName，也就是一个Advise，前提条件是这个Advise也得是一个Bean，这样Spring才能找到的，但是BeanNameAutoProxyCreator的缺点很明显，它只能根据beanName来指定想要代理的Bean。

3.3 DefaultAdvisorAutoProxyCreator 创建代理对象

@Bean
public DefaultPointcutAdvisor defaultPointcutAdvisor(){
	NameMatchMethodPointcut nameMatchMethodPointcut = new NameMatchMethodPointcut();
	nameMatchMethodPointcut.addMethodName("test");
	DefaultPointcutAdvisor pointcutAdvisor = new DefaultPointcutAdvisor();
	pointcutAdvisor.setPointcut(nameMatchMethodPointcut);
	pointcutAdvisor.setAdvice(new MethodBeforeAdvice() {
		@Override
		public void before(Method method, Object[] args, Object target) throws Throwable {
			System.out.println("DefaultPointcutAdvisor:before");
		}
	});
	return pointcutAdvisor;
}


@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
	DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
	return defaultAdvisorAutoProxyCreator;
}

通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean，根据Advisor中的PointCut和Advice信息，确定要代理的Bean以及代理逻辑。

但是，我们发现，通过这种方式，我们得依靠某一个类来实现定义我们的Advisor，或者Advise，或 者Pointcut，那么这个步骤能不能更加简化一点呢？

@Aspect 
@Component 
public class HzgAspect { 
	@Before("execution(public void com.huazige.service.UserService.test())") 
	public void HzgBefore(JoinPoint joinPoint) { 
		System.out.println("hzgBefore"); 
	} 
}

通过上面这个类，我们就直接定义好了所要代理的方法(通过一个表达式)，以及代理逻辑（被 @Before修饰的方法），简单明了，这样对于Spring来说，它要做的就是来解析这些注解了，解析之后得到对应的Pointcut对象、Advice对象，生成Advisor对象，扔进ProxyFactory中，进而产生对应的代理对象，具体怎么解析这些注解就是**@EnableAspectJAutoProxy注解**所要做的事情了，后面详细分析。

4.对Spring AOP的理解

OOP表示面向对象编程，是一种编程思想，AOP表示面向切面编程，也是一种编程思想，而我们上面所描述的就是Spring为了让程序员更加方便的做到面向切面编程所提供的技术支持，换句话说，就是Spring提供了一套机制，可以让我们更加容易的来进行AOP，所以这套机制我们也可以称之为 Spring AOP。

但是值得注意的是，上面所提供的注解的方式来定义Pointcut和Advice，Spring并不是首创，首创是 AspectJ，而且也不仅仅只有Spring提供了一套机制来支持AOP，还有比如 JBoss 4.0、aspectwerkz 等技术都提供了对于AOP的支持。而刚刚说的注解的方式，Spring是依赖了AspectJ的，或者说， Spring是直接把AspectJ中所定义的那些注解直接拿过来用，自己没有再重复定义了，不过也仅仅只 是把注解的定义赋值过来了，每个注解具体底层是怎么解析的，还是Spring自己做的，所以我们在用Spring时，如果你想用@Before、@Around等注解，是需要单独引入aspecj相关jar包的。

值得注意的是：AspectJ是在编译时对字节码进行了修改，是直接在UserService类对应的字节码中进 行增强的，也就是可以理解为是在编译时就会去解析@Before这些注解，然后得到代理逻辑，加入到 被代理的类中的字节码中去的，所以如果想用AspectJ技术来生成代理对象 ，是需要用单独的 AspectJ编译器的。我们在项目中很少这么用，我们仅仅只是用了@Before这些注解，而我们在启动 Spring的过程中，Spring会去解析这些注解，然后利用动态代理机制生成代理对象的。

5.AOP中的概念

AOP中的这些概念不是Spring特有的，不幸的是，AOP中的概念不是特别直观的，但是， 如果Spring重新定义自己的那可能会导致更加混乱

  1. Aspect：表示切面，比如被@Aspect注解的类就是切面，可以在切面中去定义Pointcut、 Advice等等
  2. Join point：表示连接点，表示一个程序在执行过程中的一个点，比如一个方法的执行，比如一 个异常的处理，在Spring AOP中，一个连接点通常表示一个方法的执行。
  3. Advice：表示通知，表示在一个特定连接点上所采取的动作。Advice分为不同的类型，后面详细讨论，在很多AOP框架中，包括Spring，会用Interceptor拦截器来实现Advice，并且在连接 点周围维护一个Interceptor链
  4. Pointcut：表示切点，用来匹配一个或多个连接点，Advice与切点表达式是关联在一起的， Advice将会执行在和切点表达式所匹配的连接点上
  5. Introduction：可以使用@DeclareParents来给所匹配的类添加一个接口，并指定一个默认实现
  6. Target object：目标对象，被代理对象
  7. AOP proxy：表示代理工厂，用来创建代理对象的，在Spring Framework中，要么是JDK动态 代理，要么是CGLIB代理
  8. Weaving：表示织入，表示创建代理对象的动作，这个动作可以发生在编译时期（比如 Aspejctj），或者运行时，比如Spring AOP

Spring会把五个注解解析为对应的Advice类：

  1. @Before：AspectJMethodBeforeAdvice，实际上就是一个MethodBeforeAdvice
  2. @AfterReturning：AspectJAfterReturningAdvice，实际上就是一个AfterReturningAdvice
  3. @AfterThrowing：AspectJAfterThrowingAdvice，实际上就是一个MethodInterceptor
  4. @After：AspectJAfterAdvice，实际上就是一个MethodInterceptor
  5. @Around：AspectJAroundAdvice，实际上就是一个MethodInterceptor

6. TargetSource的使用

在我们日常的AOP中，被代理对象就是Bean对象，是由BeanFactory给我们创建出来的，但是 Spring AOP中提供了TargetSource机制，可以让我们用来自定义逻辑来创建被代理对象。 比如@Lazy注解，当加在属性上时，会产生一个代理对象赋值给这个属性，产生代理对象的代码为：

protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
		BeanFactory beanFactory = getBeanFactory();
		Assert.state(beanFactory instanceof DefaultListableBeanFactory,
				"BeanFactory needs to be a DefaultListableBeanFactory");
		final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;

		TargetSource ts = new TargetSource() {
			@Override
			public Class<?> getTargetClass() {
				return descriptor.getDependencyType();
			}
			@Override
			public boolean isStatic() {
				return false;
			}
			@Override
			public Object getTarget() {
				Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);
				Object target = dlbf.doResolveDependency(descriptor, beanName, autowiredBeanNames, null);
				if (target == null) {
					Class<?> type = getTargetClass();
					if (Map.class == type) {
						return Collections.emptyMap();
					}
					else if (List.class == type) {
						return Collections.emptyList();
					}
					else if (Set.class == type || Collection.class == type) {
						return Collections.emptySet();
					}
					throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
							"Optional dependency not present for lazy injection point");
				}
				if (autowiredBeanNames != null) {
					for (String autowiredBeanName : autowiredBeanNames) {
						if (dlbf.containsBean(autowiredBeanName)) {
							dlbf.registerDependentBean(autowiredBeanName, beanName);
						}
					}
				}
				return target;
			}
			@Override
			public void releaseTarget(Object target) {
			}
		};

		ProxyFactory pf = new ProxyFactory();
		pf.setTargetSource(ts);
		Class<?> dependencyType = descriptor.getDependencyType();
		if (dependencyType.isInterface()) {
			pf.addInterface(dependencyType);
		}
		return pf.getProxy(dlbf.getBeanClassLoader());
	}

这段代码就利用了ProxyFactory来生成代理对象，以及使用了TargetSource，以达到代理对象在执行某个方法时，调用TargetSource的getTarget()方法实时得到一个被代理对象。

7. ProxyFactory选择cglib或jdk动态代理原理

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// 如果ProxyFactory的isOptimize为true，Spring认为cglib比jdk动态代理要快
		// 或者isProxyTargetClass为true，
		// 或者被代理对象没有实现接口，
		// 或者只实现了SpringProxy这个接口
		// 那么则利用Cglib进行动态代理，但如果被代理类是接口，或者被代理类已经是进行过JDK动态代理而生成的代理类了则只能进行JDK动态代理
		// 其他情况都会进行JDK动态代理，比如被代理类实现了除SpringProxy接口之外的其他接口
		// 是不是在GraalVM虚拟机上运行
		if (!NativeDetector.inNativeImage() &&
				(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.");
			}
			// targetClass是接口，直接使用Jdk动态代理
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			// 使用Cglib
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			//使用jdk动态代理
			return new JdkDynamicAopProxy(config);
		}
	}

7.1 ProxyFactory代理对象过程

JdkDynamicAopProxy

  1. 在构造JdkDynamicAopProxy对象时，会先拿到被代理对象自己所实现的接口，并且额外的增 加SpringProxy、Advised、DecoratingProxy三个接口，组合成一个Class[]，并赋值给 proxiedInterfaces属性
  2. 并且检查这些接口中是否定义了equals()、hashcode()方法
  3. 执行 Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this) ，得到代理对象， JdkDynamicAopProxy作为InvocationHandler，代理对象在执行某个方法时，会进入到 JdkDynamicAopProxy的**invoke()**方法中

ObjenesisCglibAopProxy

  1. 创建Enhancer对象
  2. 设置Enhancer的superClass为通过ProxyFactory.setTarget()所设置的对象的类
  3. 设置Enhancer的interfaces为通过ProxyFactory.addInterface()所添加的接口，以及 SpringProxy、Advised、DecoratingProxy接口
  4. 设置Enhancer的Callbacks为DynamicAdvisedInterceptor
  5. 最后创建一个代理对象，代理对象在执行某个方法时，会进入到DynamicAdvisedInterceptor的 intercept()方法中

代理对象执行过程

  1. 在使用ProxyFactory创建代理对象之前，需要往ProxyFactory先添加Advisor
  2. 代理对象在执行某个方法时，会把ProxyFactory中的Advisor拿出来和当前正在执行的方法进行 匹配筛选
  3. 把和方法所匹配的Advisor适配成MethodInterceptor
  4. 把和当前方法匹配的MethodInterceptor链，以及被代理对象、代理对象、代理类、当前 Method对象、方法参数封装为MethodInvocation对象
  5. 调用MethodInvocation的proceed()方法，开始执行各个MethodInterceptor以及被代理对象 的对应方法
  6. 按顺序调用每个MethodInterceptor的invoke()方法，并且会把MethodInvocation对象传入 invoke()方法
  7. 直到执行完最后一个MethodInterceptor了，就会调用invokeJoinpoint()方法，从而执行被代 理对象的当前方法

各注解对应的MethodInterceptor

  • @Before对应的是AspectJMethodBeforeAdvice，在进行动态代理时会把 AspectJMethodBeforeAdvice转成MethodBeforeAdviceInterceptor
    先执行advice对应的方法 再执行MethodInvocation的proceed()，会执行下一个Interceptor，如果没有下一个 Interceptor了，会执行target对应的方法
  • @After对应的是AspectJAfterAdvice，直接实现了MethodInterceptor 先执行MethodInvocation的proceed()，会执行下一个Interceptor，如果没有下一个 Interceptor了，会执行target对应的方法 再执行advice对应的方法
  • @Around对应的是AspectJAroundAdvice，直接实现了MethodInterceptor 直接执行advice对应的方法，由@Around自己决定要不要继续往后面调用
  • @AfterThrowing对应的是AspectJAfterThrowingAdvice，直接实现了MethodInterceptor 先执行MethodInvocation的proceed()，会执行下一个Interceptor，如果没有下一个 Interceptor了，会执行target对应的方法 如果上面抛了Throwable，那么则会执行advice对应的方法
  • @AfterReturning对应的是AspectJAfterReturningAdvice，在进行动态代理时会把 AspectJAfterReturningAdvice转成AfterReturningAdviceInterceptor 先执行MethodInvocation的proceed()，会执行下一个Interceptor，如果没有下一个 Interceptor了，会执行target对应的方法 执行上面的方法后得到最终的方法的返回值
    再执行Advice对应的方法

7.2 AbstractAdvisorAutoProxyCreator

DefaultAdvisorAutoProxyCreator的父类是AbstractAdvisorAutoProxyCreator。
AbstractAdvisorAutoProxyCreator非常强大以及重要，只要Spring容器中存在这个类型的 Bean，就相当于开启了AOP，AbstractAdvisorAutoProxyCreator实际上就是一个 BeanPostProcessor，所以在创建某个Bean时，就会进入到它对应的生命周期方法中，

比如：在某个Bean初始化之后，会调用wrapIfNecessary()方法进行AOP，底层逻辑是， AbstractAdvisorAutoProxyCreator会找到所有的Advisor，然后判断当前这个Bean是否存在某个 Advisor与之匹配（根据Pointcut），如果匹配就表示当前这个Bean有对应的切面逻辑，需要进行 AOP，需要产生一个代理对象。

7.3 @EnableAspectJAutoProxy

这个注解主要就是往Spring容器中添加了一个AnnotationAwareAspectJAutoProxyCreator类型的 Bean。

在这里插入图片描述
AspectJAwareAdvisorAutoProxyCreator继承了AbstractAdvisorAutoProxyCreator，重写了 findCandidateAdvisors()方法，AbstractAdvisorAutoProxyCreator只能找到所有Advisor类型的Bean对象，但是AspectJAwareAdvisorAutoProxyCreator除开可以找到所有Advisor类型的 Bean对象，还能把@Aspect注解所标注的Bean中的@Before等注解及方法进行解析，并生成对应的 Advisor对象。 所以，我们可以理解@EnableAspectJAutoProxy，其实就是像Spring容器中添加了一个 AbstractAdvisorAutoProxyCreator类型的Bean，从而开启了AOP，并且还会解析@Before等注解生成Advisor。

华子哥、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringAOP底层代码实现
weixin_45958862的博客
08-06 162
SpringAOP底层代码实现AOPspringAOP的代理模式jdk代理目标类接口目标类增强类动态代理代码cglib代理所需依赖目标类增强类动态代理代码 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 简单来说：AOP有助于我们将不同但是有必要的重复性代码集中管理起来复用，而不是每次都要重复写一遍。 AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spri
【spring源码】AOP底层源码分析
热门推荐
aaa_bbb_ccc_123_456的博客
01-07 1万+
【spring源码】AOP底层源码分析1.测试用例2.AOP流程概述3.AOP源码分析 spring的AOP是什么不在赘述，以下内容默认大家会使用AOP，我们今天来扒源码 1.测试用例 引入必要依赖: <dependencies> <dependency> <groupId>org.springframework&l...
Spring之AOP底层源码解析(一)
枫度柚子
04-23 378
Spring之AOP底层源码解析 动态代理 ProxyFactory Advice的分类 Advisor的理解 创建代理对象的方式 ProxyFactoryBean BeanNameAutoProxyCreator DefaultAdvisorAutoProxyCreator 对Spring AOP的理解 AOP中的概念 Advice在Spring AOP中对应API TargetSource的使用 Introduction LoadTimeWeaver 动态代理 代理的解释
Spring之AOP底层源码解析
JavaAlenboy
02-17 490
DefaultAdvisorAutoProxyCreator 的父类是 AbstractAdvisorAutoProxyCreator。AbstractAdvisorAutoProxyCreator 非常强大以及重要，只要 Spring 容器中存在这个类型的 Bean，就相当于开启了 AOP，AbstractAdvisorAutoProxyCreator实际上就是一个，所以在创建某个 Bean 时，就会进入到它对应的生命周期方法中，比如在某个 Bean 初始化之后，会调用。
Spring5 框架 ---- AOP ---- 代码
09-12
Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 ...
SpringAOP介绍及源码分析
03-02
那么面向切面编程AOP（Aspect-OrientedProgramming）则可以对系统需求进行很好的模软件开发经历了从汇编语言到高级语言和从过程化编程到面向对象编程；前者是为了提高开发效率，而后者则使用了归纳法，把具有共性的...
spring-IOC-AOP调用大致过程（源码分析）
08-12
spring version: 5.0.0; jdk: 1.8 IOC大致调用顺序(IOC调用的AOP标签解析)
死磕spring源码系列-深度解析spring aop
08-30
死磕spring源码系列-深度解析spring_aop
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
Spring Aop的底层实现技术 --- Jdk动态代理原理
03-31
Spring Aop的底层实现技术 --- Jdk动态代理原理 很不错的一篇文章
Spring AOP的底层实现技术
04-03
NULL 博文链接：https://samsongbest.iteye.com/blog/1445582
四、Spring源码分析——动态代理
08-11
NULL 博文链接：https://ylxy3058.iteye.com/blog/2224140
Spring之AOP底层原理源码解析（下）
沮丧的南瓜
12-31 393
文章目录一、ProxyFactory选择cglib或jdk动态代理原理二、代理对象创建过程2.1 JdkDynamicAopProxy2.2 ObjenesisCglibAopProxy三、代理对象执行过程四、各注解对应的MethodInterceptor五、AbstractAdvisorAutoProxyCreator六、@EnableAspectJAutoProxy七、Spring中AOP原理流程图 一、ProxyFactory选择cglib或jdk动态代理原理 ProxyFactory在生成代理对象之
Spring之AOP底层源码解析(二)
枫度柚子
04-24 378
Spring之AOP底层源码解析 ProxyFactory选择cglib或jdk动态代理原理 代理对象创建过程 JdkDynamicAopProxy ObjenesisCglibAopProxy 代理对象执行过程 各注解对应的MethodInterceptor AbstractAdvisorAutoProxyCreator @EnableAspectJAutoProxy Spring中AOP底层原理 ProxyFactory选择cglib或jdk动态代理原理 ProxyFacto
SpringAop及底层源码分析
weixin_44867712的博客
11-22 218
理解AOP是什么 AOP是Aspect-oriented programming 面向切面（方面）编程的简写 AOP的实现可以对业务逻辑和系统级的服务（系统日志，事务，权限验证）进行隔离，使业务逻辑跟各系统服务间的业务逻辑耦合度降低，font color=#FF0000 >提高代码的利用率与开发效率。 AOP的实现是通过动态代理实现的 有两种实现方式JDK 动态代理来和CGLIB动态代理 J...
P7面试必备--springAOP底层源码深度解析
Java团长的博客
08-12 198
作为Java开源世界的第一框架，Spring为应用程序的开发提供强大的支持，例如对事务处理和持久化的支持等。Spring作为Java发展史上不可忽视的存在，说他重新定义了...
Spring源码-AOP(三)-Spring AOP的四种实现
weixin_33739646的博客
08-13 271
2019独角兽企业重金招聘Python工程师标准>>> ...
spring创建Aop代理底层实现和源码分析
one_dayR的博客
01-04 256
创建AOP代理 AbstractAutoProxyCreator类中创建我们需要的bean和切面 public Object postProcessBeforeInstantiation(Class&lt;?&gt; beanClass, String beanName) throws BeansException {//每一次创建bean之前调用         Object cache...
spring-boot-starter-aop
最新发布
04-02
The spring-boot-starter-aop is a starter module in the Spring Boot framework that provides support for Aspect-Oriented Programming (AOP). AOP is a programming paradigm that enables the separation of ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值