模拟实现 Spring AOP

最新推荐文章于 2024-07-18 16:02:28 发布
最新推荐文章于 2024-07-18 16:02:28 发布
阅读量1.2k 收藏 4
点赞数 3
分类专栏： 框架项目及主流框架应用 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SwaggerHB/article/details/131131576
版权

文章目录

前言

Spring 是一种 Java 开发框架，其主要功能有两个：IoC(DI)和AOP。《模拟实现Spring AOP》是本人的一个编程训练项目，为了提升本人的编程能力、JAVA 编程思想，基于框架的角度出发，对 Spring AOP有一个更深层次的认识，动态代理模式的底层实现逻辑有更深的理解。

博主本人初入 Java 不久，能力有限，只将 Spring AOP完成到：实现了基于代理机制的拦截器链以及基于正则的配置；

Spring AOP

AOP（面向切面编程），通过预编译方式和运行期动态代理来实现程序功能的统一与扩展的技术。

Spring AOP 概述

AOP（Aspect Oriented Programming，面向切面编程）是一种编程思想，它的主要目的是将通用功能从业务逻辑中抽离出来，以达到代码复用和模块化的目的。AOP的基本概念包括：

  • 切面（Aspect）：切面是一个模块化的关注点，通常包含一个或多个通知（Advice）和切入点（Pointcut）的组合。切面的作用是将横切关注点模块化，以便于重用和维护。
  • 通知（Advice）：通知是切面中执行的具体操作。通知有五种类型：前置通知（Before）、后置通知（After）、返回通知（AfterReturning）、异常通知（AfterThrowing）和环绕通知（Around）。
  • 切入点（Pointcut）：切入点是一个表达式，用于定义在哪些方法上应用通知。切入点可以使用通配符匹配方法名、参数类型和返回值类型。
  • 连接点（JoinPoint）：连接点是程序执行过程中的某个特定的点，例如方法执行、异常抛出等。切面可以在连接点附近织入通知。
  • 织入（Weaving）：织入是将切面代码插入到目标类中的过程。织入可以在编译期（Compile-time）、类加载期（Load-time）或运行期（Runtime）完成。

AOP可以对业务逻辑部分进行隔离，从而使业务逻辑耦合降低，提高代码复用和开发效率。是基于动态代理实现的，如果目标对象实现了接口，就用 JDK 动态代理，未实现接口就用 CGLIB 动态代理。通过 AOP 技术，在不修改源代码的情况下，为程序添加了新的功能，是对程序的非侵入式扩展。

Spring IoC 技术难点

  • 拦截器的实现（代理模式的应用）
  • 基于正则的配置

Spring IoC 框架思考

需求分析

  • 代理对象的获取

    • JDKProxy 代理模式实现

      public class JDKProxy {
	private static IntercepterChain chain;

	public JDKProxy() {
	}
	
	public void addIntercepter(String targetMethod, IIntercepter intercepter) {
		JDKProxy.chain.addIntercepter(targetMethod, intercepter);
	}

	public <T> T getProxy(Object object) {
		Class<?> klass = object.getClass();
		ClassLoader loader = klass.getClassLoader();
		Class<?>[] interfaces = klass.getInterfaces();
		
		InvocationHandler h = new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				return JDKProxy.chain.doInvoker(object, method, args);
			}
		};
		
		@SuppressWarnings("unchecked")
		T proxy = (T) Proxy.newProxyInstance(loader, interfaces, h);
		
		return proxy;
	}
}

    • CGLibProxy 代理模式实现

      public class CGLibProxy {

	public CGLibProxy() {
	}

	@SuppressWarnings("unchecked")
	public <T> T getProxy(Object object) {
		Class<?> klass = object.getClass();
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(klass);
		
		enhancer.setCallback(new InvocationHandler() {
			@Override
			public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
				return null;
			}
		});
		
		return (T) enhancer.create();
	}
}

  • 切点的匹配以及拦截器链的实现

  • 对代理对象执行方法的参数以及结果的获取与处理

Spring IoC 技术难点实现

  • 拦截器的实现（代理模式的应用）

    拦截器：是一种可以在方法执行前、后、异常发生时执行的逻辑，并且，这些逻辑可以“堆叠”，形成拦截器链，或者，拦截器堆栈。

    可以通过“增加拦截器”或者“删除拦截器”的方式，对拦截器进行编辑；拦截器应该是针对某个、某些方法的。

    无论如何，拦截器技术是基于代理机制的。那么，必须提供“取得代理对象”的方法。

    前置拦截器：前置拦截器可以决定是否继续执行目标方法，也就是说，前置拦截器应该允许返回逻辑值，以确定是否继续执行目标方法；而且，对于由多个拦截器组成的拦截器链，任何一个拦截器返回值若为 false，则，所有其后的前置拦截器，以及方法本身，都不再执行！这可以称为：方法的中断。

    通常情况下，前置拦截器按照拦截器添加顺序执行(即，队列模式————先进先服务)；后置拦截器按照添加逆序执行(即，堆栈模式————先进后服务)。

    public class IntercepterChain {
	private Intercepter intercepter;
	private IntercepterChain next;
	
	public IntercepterChain() {
		this.intercepter = null;
		this.next = null;
	}
	//增加拦截器
	public void addIntercepter(String targetMethod, IIntercepter intercepter) {
		if (this.intercepter == null) {
			this.intercepter = new Intercepter(targetMethod, intercepter);
			return;
		}
		
		if (this.next == null) {
			this.next = new IntercepterChain();
		}
		this.next.addIntercepter(targetMethod, intercepter);
	}
	//反射执行方法
	public Object doInvoker(Object object, Method method, Object[] args) throws Throwable {
		Object result = null;
		
		if (this.intercepter == null) {
			return method.invoke(object, args);
		}
		
		if (this.intercepter.before(method, args)) {
			if (this.next != null) {
				result = this.next.doInvoker(object, method, args);
			}
			
			if (this.next == null) {
				result = method.invoke(object, args);
			}
			
			result = this.intercepter.after(method, result);		
		}	
		return result;
	}
}

  • 基于正则的配置

    由于想匹配到切点就必须提供方法的全类名以及参数的全类名，对于使用者来说很不方便，采用正则表达式来处理匹配切点。用户只需要提供一个普通的类名、或方法名及参数，对于其他的不确定的地方使用‘*’来代替，当用户调用到添加拦截器时，对于用户传入的简单切点名进行转化，MethodInvoker 类中提供了处理用户提交的普通的类名与参数名的 toRegex 方法，此方法把简单的字符串转换为正则表达式，从而找到符合的切面的切点。完成切点的匹配。

    /**
     * 用户提供切点名，*.ClassName.methodName(*)
     * 例：*.MyInterface.*(*String,*int) 表示任意长度的前一个字符，前面必须有字符
     *  故 .* 表示任意字符
     *  用户只需输入简单的参数以及方法名，不确定的地方用*代替
     *  .*IMyInterface..*\(.*String,.*int\)
     *
     */
    private String toRegex(String methodName) {
        StringBuffer stringBuffer = new StringBuffer();
        //将不确定的地方替换为.*表示匹配任意字符
        String buffer = methodName.replace("*", ".*");
 
        int left =buffer.indexOf("(");
        int right = buffer.indexOf(")");
        //得到类名与方法名
        stringBuffer.append(".*").append(buffer.substring(0, left)).append("\\(");
 
        //按照逗号分割出参数字符串数组
        String[] args = buffer.substring(left + 1, right).split(",");
        for(int i = 0; i < args.length; i++) {
            stringBuffer.append((i == 0 ? "" : ",")).append(".*").append(args[i]);
        }
        stringBuffer.append("\\)");
        return stringBuffer.toString();
    }

模拟实现 AOP 具体代码

为了在目标方法前后执行新的方法，且不对源代码进行修改，所以要用动态代理，让代理去执行目标方法，然后在执行方法前进行前置拦截，在执行方法后进行后置拦截。

  • JDK 动态代理

    public class JDKProxy {
	private static IntercepterChain chain;

	public JDKProxy() {
	}
	
	public void addIntercepter(String targetMethod, IIntercepter intercepter) {
		JDKProxy.chain.addIntercepter(targetMethod, intercepter);
	}

	public <T> T getProxy(Object object) {
		Class<?> klass = object.getClass();
		ClassLoader loader = klass.getClassLoader();
		Class<?>[] interfaces = klass.getInterfaces();
		
		InvocationHandler h = new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				return JDKProxy.chain.doInvoker(object, method, args);
			}
		};
		
		@SuppressWarnings("unchecked")
		T proxy = (T) Proxy.newProxyInstance(loader, interfaces, h);
		
		return proxy;
	}
}

  • Result 类

    public class Result {
	private static Object result;
	
	Result() {
	}
	……getter、setter
}

  • 拦截器链实现

    public class IntercepterChain {
	private Intercepter intercepter;
	private IntercepterChain next;
	
	public IntercepterChain() {
		this.intercepter = null;
		this.next = null;
	}
	//增加拦截器
	public void addIntercepter(String targetMethod, IIntercepter intercepter) {
		if (this.intercepter == null) {
			this.intercepter = new Intercepter(targetMethod, intercepter);
			return;
		}
		
		if (this.next == null) {
			this.next = new IntercepterChain();
		}
		this.next.addIntercepter(targetMethod, intercepter);
	}
	//反射执行方法
	public Object doInvoker(Object object, Method method, Object[] args) throws Throwable {
		Object result = null;
		
		if (this.intercepter == null) {
			return method.invoke(object, args);
		}
		
		if (this.intercepter.before(method, args)) {
			if (this.next != null) {
				result = this.next.doInvoker(object, method, args);
			}
			
			if (this.next == null) {
				result = method.invoke(object, args);
			}
			
			result = this.intercepter.after(method, result);		
		}	
		return result;
	}
}

  • 接口

    public interface IIntercepter {
	boolean before();	//前置拦截
	void after();		//后置拦截
}

  • 拦截器

    //获取代理对象，并且在before()内部采用正则表达式来有选择的进行拦截处理。
//当before()方法返回值为true时，则可以正常执行目标方法，否则不执行。
public class Intercepter {
	private String targetMethod;		//拦截目标
	private IIntercepter intercepter;	
	
	Intercepter(String targetMethod, IIntercepter intercepter) {
		this.targetMethod = targetMethod;
		this.intercepter = intercepter;
	}
	//前置拦截：如果返回值为false则为不允许执行下面的方法
	boolean before(Method method, Object[] args) {
		// 正则，TODO
		if (!method.toString().equals(this.targetMethod)) {
			return true;
		}
		
		Arguments.setArgs(args);
		return this.intercepter.before();
	}
	后置拦截主要针对于方法执行的结果
	Object after(Method method, Object result) {
		// 正则，TODO
		if (!method.toString().equals(this.targetMethod)) {
			return result;
		}
		
		Result.setResult(result);
		this.intercepter.after();
		
		return Result.getResult();
	}	
}

这里只是作为本人训练项目，简单的实现了 Spring AOP 中的核心功能，还需要进行更深入的学习相关知识，有问题处望大佬指出。

HB0o0
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
手动模拟实现Spring-AOP
yangsnow_rain_wind的专栏
05-07 1191
Spring中AOP设计思路是这样的. 在BeaFactory.getBean()时,调用方法initBean(); 在该方法中判断当前Bean是否含有满足SpEL表达式的Method, 没有的话, 返回原始的Bean, 有的话, 会对当前Bean做动态代理, 当代理对象的方法被调用时,会发送通知到Aop拦截器,进而实现Aop的功能. 本篇文章思路接着上篇文章, (手动模拟实现Spr...
Spring中AOP的模拟实现
kiss_vicente的专栏
10-24 3959
什么是AOP？ 面向切面编程（AOP）完善spring的依赖注入（DI），面向切面编程在spring中主要表现为两个方面 1.面向切面编程提供声明式事务管理 2.spring支持用户自定义的切面 面向切面编程（aop）是对面向对象编程（oop）的补充， 面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个切面。 AOP从程序运行角度考虑程序的结构，提
详解-手写Spring框架（结）-AOP模拟
qq_18884633的博客
07-28 107
在现代软件开发中，面向切面编程（AOP）是一个重要的概念，它可以帮助开发者实现系统中的横切关注点的解耦和重用。而Spring框架作为一个强大的Java开发框架，提供了完善的AOP支持。本篇博客将深入探索Spring中的AOP，包括AOP的基本原理、应用场景以及如何在Spring项目中实际使用AOP。面向切面编程（AOP）是一种编程范式，它通过将横切关注点（例如日志记录、事务管理等）与核心业务逻辑分离，从而实现代码的重用和维护。
使用Spring实现Aop三种方法
vengu733的博客
08-05 3175
** 方式一 ：使用spring的AP接口 方式二 ： 自定义来实现AOP (主要是切面定义) 方式三 ：使用注解实现AOP **使用AOP 植入 ，需要导入依赖包aspectj 方式一 ：使用spring的AP接口 定义uservice接口 接口实现类userviceImpl 创建要做代理 为uservice 添加日志 的log类 创建afterlog 类 ben.xml 创建测试： div 自定义一个类 bean.xml 测试结果： 分析： 创建annotation类 bean.xml 测试
（Spring笔记）AOP切面编程——模拟实现AOP
张松的博客
06-15 560
AOP全称为Aspect Oriented Programming——面向切面编程，可通过运行期动态代理实现程序功能统一维护的一种技术。AOP是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。......
【java】Spring Boot -- Spring AOP原理及简单实现
DreamSun的博客
02-14 1407
一般情况下数据被过滤的时机越早对服务的性能影响越小，因此我们在编写相对比较公用的代码时，优先考虑过滤器，然后是拦截器，最后是AOP。针对问题2，我们可以定义一个BeanFactoryPostProcessor的实现类，完成对所有BeanDefinition的扫描，找出我们定义的所有的切面类，然后循环里面的方法，找到切点、以及所有的通知方法，然后根据注解判断通知类型（也就是前置，后置还是环绕），最后解析切点的内容，扫描出所有的目标类，放入我们定义好的容器中。拦截器使用是反射机制。
spring AOP 实现原理模拟实现
丁辉-blog
09-16 1982
接着上篇spring IOC ,测试代码链接请到上篇文章找。 利用Java的反射与代理实现AOP 一．AOP概述       AOP(Aspect Oriented Programing)，即面向切面编程，它主要用于日志记录、性能统计、安全控制、事务处理、异常处理等方面。它的主要意图就要将日志记录，性能统计，安全控制、事务处理、异常处理等等代码从业务逻辑代码中清楚地划分出来。通
个人用java动态代理模拟实现spring aop
07-30
在本主题中，我们将探讨如何使用Java动态代理来模拟实现Spring AOP的功能。 首先，我们需要了解Java中的两种动态代理机制：JDK动态代理和CGLIB动态代理。JDK动态代理基于接口实现，适用于目标对象实现了接口的情况...
模拟spring aop技术
05-02
**模拟Spring AOP技术** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要组件，它提供了一种在不修改源代码的情况下，通过代理模式来实现横切关注点（如日志、事务管理等）的...
以注解方式模拟Spring IoC AOP
09-12
Spring提供了两种主要的AOP实现方式：基于代理（Proxy-based）和基于注解（Annotation-based）。 - **基于代理的AOP**：Spring使用JDK动态代理或CGLIB动态代理创建目标对象的代理，代理对象在调用目标方法前后执行...
Spring AOP简单模拟
05-25
模拟AOP源码 博文链接：https://senny.iteye.com/blog/466622
Spring AOP中定义切点的实现方法示例
08-25
Spring AOP 中定义切点的实现方法示例 在 Spring 框架中，Aspect-Oriented Programming（面向切面编程）是一种非常重要的编程范式，它能够帮助开发者实现各种横切关注点的模块化。其中，定义切点是 AOP 中最为关键...
Spring AOP面向切面编程+动态实现AOP框架
qq_54048628的博客
07-03 210
AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。它采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式。AOP 的底层是通过Spring提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强，可以在不改变原来代码的基础上，通过“动态注入”代码，来改变原来执行结果的技术。
SpringAOP的实现
y393016244的博客
11-29 371
1、横切关注点：跨越应用程序多个模块的方法或功能。即，与我们业务逻辑无关的，但我们需要关注的部分，就是横切关注点。如：日志、缓存、事务等等…。2、切面（Aspect）：横切关注点被实例化的特殊对象，即，他是一个类。3、通知（Advice）：切面一定要完成的工作。即，他是一个切面类中的方法。4、目标（Target）：被通知的目标对象。即，实际要被执行的对象。5、代理（Proxy）：向目标对象应用通知之后创建的对象。6、切入点（PointCut）：切面通知执行的“地点”的定义。7、
Spring中实现AOP的功能
yu的博客
09-12 501
Spring中实现AOP的功能（四种方式）
Spring之模拟实现AOP的功能(模拟Before,After,Around,AfterThrowing,AfterReturn)
编程学习者的博客
04-12 234
1.声明 当前的内容用于模拟当前Spring的AOP功能，主要用于本人理解或者学习之用！ 基本的代理实现主要通过这两个是实现：Proxy和InvocationHandler 2.定义基本的接口和实例 fly接口 public interface Fly { void fly(); } 鸭子 public class Duck implements Fly { @Override pu...
Spring 面向切面编程 第4关：AOP实现原理-CgLib动态代理
于建章的博客
11-03 2287
Spring 面向切面编程 第4关：AOP实现原理-CgLib动态代理
手写spring（7）- AOP模拟实现
weixin_42478399的博客
12-26 272
AOP就是通过BeanPostProcessor的postProcessorAfterInitialization方法（初始化后）实现的 AOP常见的时候方法有cglib与JDK动态代理，项目中采用JDK动态代理实现AOP。使用JDK动态代理要求bean实现接口，项目中定义了UserService这个接口 public interface UserService { void test(); } UserServiceImpl实现了UserService接口 public class UserSe
Spring纯注解开发
最新发布
Admans的专栏
07-18 494
Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦注解开发前，配置Bean时是在xml里将class分别写在Bean标签里，然后起id，就像这样注解开发后，配置Bean时首先将xml里的标签删掉，然后在类上添加@Component注解即可在xml文件中来写一个扫描包的注解标签，对象就装进IOC容器里了component-scan:component意为组件，scan意为扫描。
SpringAOP+自定义注解模拟shiro框架实现
06-06
首先，我们需要定义一个自定义注解 `@RequiresPermissions`，用于标识需要授权访问的方法，例如： ```java @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface RequiresPermissions { String[] value(); // 权限值 } ``` 然后，我们需要实现一个切面，用于拦截被 `@RequiresPermissions` 标识的方法，并进行权限校验，例如： ```java @Component @Aspect public class PermissionCheckAspect { @Autowired private AuthService authService; @Around("@annotation(requiresPermissions)") public Object checkPermission(ProceedingJoinPoint joinPoint, RequiresPermissions requiresPermissions) throws Throwable { // 获取当前用户 User user = authService.getCurrentUser(); if (user == null) { throw new UnauthorizedException("用户未登录"); } // 获取当前用户的权限列表 List<String> permissions = authService.getUserPermissions(user); // 校验权限 for (String permission : requiresPermissions.value()) { if (!permissions.contains(permission)) { throw new ForbiddenException("没有访问权限：" + permission); } } // 执行目标方法 return joinPoint.proceed(); } } ``` 在切面中，我们首先通过 `AuthService` 获取当前用户及其权限列表，然后校验当前用户是否拥有被 `@RequiresPermissions` 标识的方法所需的所有权限，如果没有则抛出 `ForbiddenException` 异常，如果有则继续执行目标方法。 最后，我们需要在 Spring 配置文件中启用 AOP 自动代理，并扫描切面所在的包，例如： ```xml <aop:aspectj-autoproxy /> <context:component-scan base-package="com.example.aspect" /> ``` 这样，我们就通过 Spring AOP 和自定义注解模拟实现了类似 Shiro 权限校验的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HB0o0

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值