Spring容器10AOP JDK+CGLIB

最新推荐文章于 2022-11-10 17:41:58 发布
最新推荐文章于 2022-11-10 17:41:58 发布
阅读量93 收藏 1
点赞数 1
分类专栏： 后端 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43373818/article/details/117416232
版权

源码参考：github上的code4craft/tiny-spring项目。

tiny-spring-step-10-invite-cglib-and-aopproxy-factory

文章目录

源码解析

警告：请参考github上的源码，不然理解起来比较困难。

  1. 切点（Pointcut）和通知（Advice）
  2. 整合到Spring容器中

在这里插入图片描述

目录结构

  1. AbstractAopProxy
    实现AopProxy，依赖了代理的元数据信息。
  2. AdvisedSupport
    代理的元数据信息，记录对哪个对象的哪个方法进行了增强。
  3. Advisor
    通知器的抽象，管理通知
  4. AopProxy
    AOP代理的抽象
  5. AspectJAroundAdvice
    通知的具体实现
  6. AspectJAwareAdvisorAutoProxyCreator
    将代理整合到spring中，使用了BeanPostProcessor, BeanFactoryAware
  7. AspectJExpressionPointcut
    切点的具体实现
  8. AspectJExpressionPointcutAdvisor
    切点通知器的实现，管理切点和通知
  9. BeanFactoryAware
    提供BeanFactory
  10. Cglib2AopProxy
    Cglib的AopProxy实现
  11. ClassFilter
    类过滤器抽象
  12. JdkDynamicAopProxy
    Jdk的AopProxy实现
  13. MethodMatcher
    方法匹配抽象
  14. Pointcut
    切点抽象
  15. PointcutAdvisor
    切点通知器抽象
  16. ProxyFactory
    Proxy创建工厂
  17. ReflectiveMethodInvocation
    方法处理，Joinpoint的具体实现
  18. TargetSource
    目标对象的信息

切点（Pointcut）

Pointcut是对AOP对切点的高级抽象。主要作用是类的过滤以及方法的匹配

public interface Pointcut {

    ClassFilter getClassFilter();

    MethodMatcher getMethodMatcher();

}

public interface MethodMatcher {

    boolean matches(Method method, Class targetClass);
}

public interface ClassFilter {

    boolean matches(Class targetClass);
}

实现类：AspectJExpressionPointcut

public class AspectJExpressionPointcut implements Pointcut, ClassFilter, MethodMatcher {

	private PointcutParser pointcutParser;

	private String expression;

	private PointcutExpression pointcutExpression;

	private static final Set<PointcutPrimitive> DEFAULT_SUPPORTED_PRIMITIVES = new HashSet<PointcutPrimitive>();

	static {
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
	}

	public AspectJExpressionPointcut() {
		this(DEFAULT_SUPPORTED_PRIMITIVES);
	}

	public AspectJExpressionPointcut(Set<PointcutPrimitive> supportedPrimitives) {
		pointcutParser = PointcutParser
				.getPointcutParserSupportingSpecifiedPrimitivesAndUsingContextClassloaderForResolution(supportedPrimitives);
	}

	protected void checkReadyToMatch() {
		if (pointcutExpression == null) {
			pointcutExpression = buildPointcutExpression();
		}
	}

	private PointcutExpression buildPointcutExpression() {
		return pointcutParser.parsePointcutExpression(expression);
	}

	public void setExpression(String expression) {
		this.expression = expression;
	}

	@Override
	public ClassFilter getClassFilter() {
		return this;
	}

	@Override
	public MethodMatcher getMethodMatcher() {
		return this;
	}

	@Override
	public boolean matches(Class targetClass) {
		checkReadyToMatch();
		return pointcutExpression.couldMatchJoinPointsInType(targetClass);
	}

	@Override
	public boolean matches(Method method, Class targetClass) {
		checkReadyToMatch();
		ShadowMatch shadowMatch = pointcutExpression.matchesMethodExecution(method);
		if (shadowMatch.alwaysMatches()) {
			return true;
		} else if (shadowMatch.neverMatches()) {
			return false;
		}
		// TODO:其他情况不判断了！见org.springframework.aop.aspectj.RuntimeTestWalker
		return false;
	}
}

管理切点的工具：PointcutAdvisor

public interface PointcutAdvisor extends Advisor{
	//切点通知器管理了切点和通知
   Pointcut getPointcut();
}

通知（Advice）

Advice是对AOP的高层级抽象，主要作用的增强逻辑的实现。advice的实现是MethodInterceptor
通知器：管理通知的工具

public interface Advisor {

    Advice getAdvice();
}

相关方法的调用关系

在这里插入图片描述

AOP代理

是对代理的高级抽象

public interface AopProxy {

    Object getProxy();
}

抽象实现类

public abstract class AbstractAopProxy implements AopProxy {

    protected AdvisedSupport advised;

    public AbstractAopProxy(AdvisedSupport advised) {
        this.advised = advised;
    }
}

JDK具体的实现

public class JdkDynamicAopProxy extends AbstractAopProxy implements InvocationHandler {

    public JdkDynamicAopProxy(AdvisedSupport advised) {
        super(advised);
    }

	@Override
	public Object getProxy() {
		return Proxy.newProxyInstance(getClass().getClassLoader(), advised.getTargetSource().getInterfaces(), this);
	}

	@Override
	public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
		MethodInterceptor methodInterceptor = advised.getMethodInterceptor();
		MethodMatcher methodMatcher = advised.getMethodMatcher();
		if (methodMatcher!= null && methodMatcher.matches(method, advised.getTargetSource().getTarget().getClass())) {
			return methodInterceptor.invoke(new ReflectiveMethodInvocation(advised.getTargetSource().getTarget(),method, args));
		} else {
			return method.invoke(advised.getTargetSource().getTarget(), args);
		}
	}

}

CGLIB具体实现

public class Cglib2AopProxy extends AbstractAopProxy {

	public Cglib2AopProxy(AdvisedSupport advised) {
		super(advised);
	}

	@Override
	public Object getProxy() {
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(advised.getTargetSource().getTargetClass());
		//getInterfaces() 获得这个对象所实现的所有接口
		enhancer.setInterfaces(advised.getTargetSource().getInterfaces());
		enhancer.setCallback(new DynamicAdvisedInterceptor(advised));
		Object enhanced = enhancer.create();
		return enhanced;
	}

	private static class DynamicAdvisedInterceptor implements MethodInterceptor {

		private AdvisedSupport advised;

		private org.aopalliance.intercept.MethodInterceptor delegateMethodInterceptor;

		private DynamicAdvisedInterceptor(AdvisedSupport advised) {
			this.advised = advised;
			this.delegateMethodInterceptor = advised.getMethodInterceptor();
		}

		@Override
		public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
			if (advised.getMethodMatcher() == null|| advised.getMethodMatcher().matches(method, advised.getTargetSource().getTargetClass())) {
				return delegateMethodInterceptor.invoke(new CglibMethodInvocation(advised.getTargetSource().getTarget(), method, args, proxy));
			}
			return new CglibMethodInvocation(advised.getTargetSource().getTarget(), method, args, proxy).proceed();
		}
	}

	private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

		private final MethodProxy methodProxy;

		public CglibMethodInvocation(Object target, Method method, Object[] args, MethodProxy methodProxy) {
			super(target, method, args);
			this.methodProxy = methodProxy;
		}

		@Override
		public Object proceed() throws Throwable {
			return this.methodProxy.invoke(this.target, this.arguments);
		}
	}

}

被代理的对象

public class TargetSource {

	private Class<?> targetClass;

    private Class<?>[] interfaces;

	private Object target;
}

AspectJAroundAdvice是通知的具体实现：增强逻辑的实现
AspectJExpressionPointcut是切点的具体实现：类过滤，方法匹配
AspectJExpressionPointcutAdvisor是切点通知器的具体实现：管理切点和通知

与容器整合AspectJAwareAdvisorAutoProxyCreator，在bean初始化的前后实现创建代理对象。

public class AspectJAwareAdvisorAutoProxyCreator implements BeanPostProcessor, BeanFactoryAware {

	private AbstractBeanFactory beanFactory;

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws Exception {
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws Exception {
		if (bean instanceof AspectJExpressionPointcutAdvisor) {
			return bean;
		}
		if (bean instanceof MethodInterceptor) {
			return bean;
		}
		List<AspectJExpressionPointcutAdvisor> advisors = beanFactory
				.getBeansForType(AspectJExpressionPointcutAdvisor.class);
		for (AspectJExpressionPointcutAdvisor advisor : advisors) {
			if (advisor.getPointcut().getClassFilter().matches(bean.getClass())) {
                ProxyFactory advisedSupport = new ProxyFactory();
				advisedSupport.setMethodInterceptor((MethodInterceptor) advisor.getAdvice());
				advisedSupport.setMethodMatcher(advisor.getPointcut().getMethodMatcher());

				TargetSource targetSource = new TargetSource(bean, bean.getClass(), bean.getClass().getInterfaces());
				advisedSupport.setTargetSource(targetSource);

				return advisedSupport.getProxy();
			}
		}
		return bean;
	}

	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws Exception {
		this.beanFactory = (AbstractBeanFactory) beanFactory;
	}
}

调用顺序

在这里插入图片描述

测试

这个测试非常具有代表性

public class JdkDynamicAopProxyTest {

	@Test
	public void testInterceptor() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("tinyioc.xml");
		HelloWorldService helloWorldService = (HelloWorldService) applicationContext.getBean("helloWorldService");
		helloWorldService.helloWorld();
		//在AspectJAwareAdvisorAutoProxyCreator中已经对bean做了CGlib代理，所以获取的是代理对象，
		//因为CGlib针对的是类，所以代理对象类型是HelloWorldServiceImpl
		System.out.println("class =" + helloWorldService.getClass().getName());//us.codecraft.tinyioc.HelloWorldServiceImpl$$EnhancerByCGLIB$$635bc03b
		System.out.println(helloWorldService instanceof Cglib2AopProxy);//false
		System.out.println(helloWorldService instanceof JdkDynamicAopProxy);//false
		System.out.println(helloWorldService instanceof HelloWorldService);//true
		System.out.println(helloWorldService instanceof HelloWorldServiceImpl);//true

		AdvisedSupport advisedSupport = new AdvisedSupport();
		TargetSource targetSource = new TargetSource(helloWorldService, HelloWorldServiceImpl.class,HelloWorldService.class);
		advisedSupport.setTargetSource(targetSource);

		TimerInterceptor timerInterceptor = new TimerInterceptor();
		advisedSupport.setMethodInterceptor(timerInterceptor);

		JdkDynamicAopProxy jdkDynamicAopProxy = new JdkDynamicAopProxy(advisedSupport);
		HelloWorldService helloWorldServiceProxy = (HelloWorldService) jdkDynamicAopProxy.getProxy();

		helloWorldServiceProxy.helloWorld();
		//上面已经使用了代理，而下面又创建了代理对象，而且是JDK实现的，
		//因为重新new JdkDynamicAopProxy()，所以获取的是新的代理对象。又因为JDK是针对接口做代理的，所以判断代理的类型是HelloWorldService
		System.out.println("class = = " + helloWorldServiceProxy.getClass().getName());//com.sun.proxy.$Proxy2
		System.out.println(helloWorldServiceProxy instanceof Cglib2AopProxy);//false
		System.out.println(helloWorldServiceProxy instanceof JdkDynamicAopProxy);//false
		System.out.println(helloWorldServiceProxy instanceof HelloWorldService);//true
		System.out.println(helloWorldServiceProxy instanceof HelloWorldServiceImpl);//false		

	}
}

tinyioc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
	http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <bean id="outputService" class="us.codecraft.tinyioc.OutputServiceImpl">
    </bean>

    <bean id="helloWorldService" class="us.codecraft.tinyioc.HelloWorldServiceImpl">
        <property name="text" value="Hello World!"></property>
        <property name="outputService" ref="outputService"></property>
    </bean>

    <bean id="autoProxyCreator" class="us.codecraft.tinyioc.aop.AspectJAwareAdvisorAutoProxyCreator"></bean>

    <bean id="timeInterceptor" class="us.codecraft.tinyioc.aop.TimerInterceptor"></bean>

    <bean id="aspectjAspect" class="us.codecraft.tinyioc.aop.AspectJExpressionPointcutAdvisor">
        <property name="advice" ref="timeInterceptor"></property>
        <property name="expression" value="execution(* us.codecraft.tinyioc.*.*(..))"></property>
    </bean>

</beans>
这个世界太疯狂了
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring框架+Spring工作原理+AOP面向切面编程+JDK代理+Cglib代理
03-13
Spring框架是一个开放源代码的J2EE应用程序框架，是对bean的生命周期进行管理的轻量级容器。 适用：中高级开发 Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork等众多Web框架组合使用，并且可以与Swing...
如何实现一个简易版的 Spring - 如何实现 AOP（下）
weixin_45032957的博客
06-07 93
解析 XML 中的 pointcut 定义及方法解析 假设有一个 OrderService 类(P.S. 这里的 @Component 是我自定义的注解，详见 这篇)，其中有一个下单的方法 placeOrder()，我们想实现的效果是想给这个 placeOrder() 方法加上 数据库事务，即执行方法之前开启事务，执行过程中发生异常回滚事务，正常执行完成提交事务。OrderService 类的代码如下： /** @author mghio @since 2021-06-06 */ @Component(v
Spring Aop 前篇-如何解析表达式
@Bean
07-20 465
Aspect 是如何解析表达式？或者说是如何通过表达式知道哪个对象需要被创建代理 Spring 在解析 @Aspect 表达式其实用到的就是Aspect 包里面的API 。 第一个对象 PointcutParser 顾名思义 切点解析器 第二个对象 PointcutExpression 切点表达式对象 如何去解析并命中对象呢 1.构建PointcutParser Aspect API PointcutParser pointcutParser = PointcutParser.getPoi..
【总结】自研Spring框架的实现总结
qq_43430343的博客
02-05 1082
实例的创建 1、创建注解@Controller、@Service、@Repository、@Component 2、提取标记对象 实现思路 ◆指定范围,获取范围内的所有类 ◆遍历所有类,获取被注解标记的类并加载进容器里 怎么根据包名获取类集合？ 创建一个方法extractPacakgeClass，利用类加载器获取资源url，再根据协议名过滤出文件类型的资源，遍历目录获得class文件，再使用反射获取对应的Class对象添加到集合中。 extractPacakgeClass里面需要完成的事情 ◆获取
tinySpring学习笔记（二）-实现AOP
ShunziZhang
08-19 342
AOP及其实现 AOP分为配置(Pointcut，Advice)，织入(Weave)两部分工作，当然还有一部分是将AOP整合到整个容器的生命周期中。 step1-使用JDK动态代理实现AOP织入 git checkout step-7-method-interceptor-by-jdk-dynamic-proxy - 织入（weave）相对简单，我们先从它开始。Sp...
从零开始造Spring07---AOP(介绍以及实现Pointcut和MethodLocatingFactory)
码农飞哥
08-07 2042
前言 本文是学习《从零开始造Spring》的学习笔记。 为什么要实现AOP
Spring框架+SpringAOP动态代理
最新发布
03-22
SpringAOP动态代理 Spring AOP 使用的动态代理主要有两种方式：JDK 动态代理和 CGLIB 代理。 JDK 动态代理：用于代理实现了接口的类。Spring 会使用 java.lang.reflect.Proxy 类来创建代理对象。 CGLIB 代理：用于...
Spring-AOP-JDK动态代理
05-12
Spring-AOP-利用java中的动态代理和Spring的拦截器做到AOP
Spring框架中JDK动态代理和cglib动态代理
11-06
Spring 框架中 JDK 动态代理和 CGLIB 动态代理是 Spring AOP 中一个非常重要的知识点。Spring AOP 框架会根据实际情况选择使用 JDK 的动态代理还是 CGLIB 的动态代理。 JDK 动态代理是 Java 自带的动态代理机制，它...
Spring AOP实现Redis缓存数据库查询
08-29
在配置中，我们需要使用JDK的动态代理，而不是cglib的代理。为此，我们需要做以下配置：<aop:aspectj-autoproxy proxy-target-class="false" />。 在使用注解时，我们定义了两个标注在接口方法上的注解，用于传递...
手写简易AOP，彻底悟懂AOP
qq_63815371的博客
11-10 586
AOP 意为：面向切面编程，通过预编译的方式和运行期间动态代理实现程序功能功能的统一维护。其实 AOP 也是 OOP 的延续，在 Spring 框架中是一个非常重要的内容，使用 AOP 可以对业务逻辑的各个部分进行隔离，从而使各模块间的业务逻辑耦合度降低，提高代码的可复用性，同时也能提高开发效率。
第二章 AOP
qq_30561643的博客
10-11 151
AOP JDK的实现 Clib的实现 源码设计 AdvisedSupport … @Data public class AdvisedSupport { private TargetSource targetSource; private MethodInterceptor methodInterceptor; private MethodMatcher methodMatc...
spring学习笔记06：AOP事务的配置
ACodeBird
08-28 162
一、导包(下面用一个转账的例子来实现)： <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <junit.version>4.12</junit.version> <c3p0.version>0...
Spring Aop源码学习--PointCut切入点
井底之蛙
07-07 5615
PointCut切入点简单来说就是用来指明Advice（增强）所作用的地方（一般指方法），PointCut简单来说是一个基于表达式的拦截条件。PointCut接口及实现类：PointCut接口提供了两个接口分别对类和方法进行匹配过滤，如果类及方法匹配成功则Advice就可以作用在方法上。public interface Pointcut { /** * Return the ClassFi
Spring的aspect无法拦截有注解的jdk代理的接口方法的原因
weixin_34247032的博客
04-27 785
Spring的aspect无法拦截有注解的jdk代理的接口方法的原因 我github博客地址 背景 项目A中需要多数据源的实现，比如UserDao.getAllUserList() 需要从readonly库中读取，但是UserDao.insert() 需要插入主(写)库 就需要在dao层的方法调用上面添加注解！ 复制代码介绍无法代理现象 定义注解 DataNotification.java @...
spring security 2.0 的简单配置使用（补）——用aop控制method级权限
孙宁振的专栏
08-18 203
上次写了spring security 2.0 的简单配置使用 ，这里再做一下补充。 method级别的权限控制可以通过spring aop来实现。 pointcut： &lt;aop:config&gt; &lt;aop:pointcut id="securityPointcut" expression="execution(** org.cats...
spring aop 代理过程,cglib
09-16
Spring AOP使用CGLIB作为默认的代理方式来实现动态代理。代理过程中，首先需要定义一个被代理的目标对象或者叫做目标类。该目标对象可以是任何一个Java对象，它会在运行时被代理创建。然后，通过Spring的配置文件...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值