简单实现 AOP

最新推荐文章于 2022-06-13 11:25:10 发布
最新推荐文章于 2022-06-13 11:25:10 发布
阅读量205 收藏 1
点赞数
文章标签： aop spring boot spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44157608/article/details/119720722
版权

AOP 面向切面编程

  1. 新建项目Spring Starter Project。
  2. 自定义注解，用于标记需要 动态插入切面 的 位置，在这里我定义了3个。
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解，标记需要检查健康码的位置
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface HealthCode {

}


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 自定义注解，标记需要进行性能分析的位置
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Timing {

}


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解，标记需要用户认证的位置
 *	其中包含一个属性：用户名，默认为User
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Auth {
	String value() default "user";
}
  1. 为每一个注解增加一个类，标记为组件 @Component 和切面 @Aspect，还可以标记其优先级 @Order，当一个方法被多个注解标记时，可以根据优先级判断切入顺序。

@Pointcut() 标记切入点 ：这里是被注解标记的方法
@Before() 指定前置通知的切入点
@After() 指定后置通知的切入点
JoinPoint 连接点：指切面切入的具体方法，通过连接点可以获取：
- 切入点 方法的名字 getSignature().getName()
-切入点方法的参数 getArgs()
- 切入点方法标注的注解对象，进而可以获取注解的信息
- …

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component // 标记为组件
@Aspect   // 标记为切面
@Order(2) // 优先级
public class HealthCodeAspect {

	// 通知(特定位置)：织入目标方法的位置
//	@Before				前置
//	@After				后置
//	@Around				环绕
//	@AfterReturning		方法返回后
//	@AfterThrowing		异常抛出后
	
	// 把重复的部分提取出来，用注解的方式标记接入点 @Pointcut，不必每次都重复写
	@Pointcut("@annotation(com.newer.aop.HealthCode)")
	public void x() {
	}
	
	// 指定前置通知的切入点，这里的 切入点 是被 注解标记的方法
	// 传入 注解的 包命+类名
	//@Before("@annotation(com.newer.aop.HealthCode)")
	@Before("x()")
	public void checkCode(JoinPoint joinpoint) {
		
		// 获得连接点，即切面切入的具体方法
		String name = joinpoint.getSignature().getName();
		System.out.printf("%s ::前置通知:检查健康码\n",name);
	}
	
	//@After("@annotation(com.newer.aop.HealthCode)")
	@After("x()")
	public void after(JoinPoint joinPoint) {
		System.out.printf("%s ::后置通知\n",joinPoint.getSignature().getName());
	}
}

@Around() ：指定环绕通知的切入点
环绕通知 = 前置 + 切面切入方法的执行 + 后置
proceed 方法就是用于启动目标方法的执行，通过Proceedingjoinpoint 对象调用

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

// 标记为 组件，切面
@Component
@Order(1)
@Aspect
public class TimingAspect {

	@Pointcut("@annotation(com.newer.aop.Timing)")
	public void y() {
		
	}
	
	// 环绕通知，切入点
	@Around("y()")
	public void aroung(ProceedingJoinPoint point) {
		System.out.printf("-----------------------%s性能分析开始\n",point.getSignature().getName());
		long time = System.currentTimeMillis();
		
		// 被切入方法的执行
		Object result = null;
		try {
			result =  point.proceed();
		} catch (Throwable e) {
			e.printStackTrace();
		}
		
		time = System.currentTimeMillis() - time;
		System.out.printf("=========%s 性能分析,耗时 %d\n",
				point.getSignature().getName(),
				time);
	
	}
}


import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

// 组件、切面
@Component
@Aspect
@Order(0)
public class AuthAspect {

	@Before("@annotation(com.newer.aop.Auth)")
	public void beforeAuth(JoinPoint joinPoint) {
		// 切入点的方法名
		String name = joinPoint.getSignature().getName();
		System.out.println("方法名："+name);
		// 切入点方法中的参数
		Object[] args = joinPoint.getArgs();
		if(args!=null) {
			for(Object obj:args) {
				System.out.println("参数："+obj);
			}
		}
		
		// 获得注解的值，进一步拓展可做权限认证等...
		MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
		Method targetMethod = methodSignature.getMethod();
		Auth ano = targetMethod.getAnnotation(Auth.class);
		System.out.println("注解标记的权限值为："+ano.value());
		System.out.println("*********************************************************");
	}
	
}
  1. 给需要动态加入公共需求的方法标记上相对应的注解。
import org.springframework.stereotype.Component;

@Component
public class Life {

	// 织入（一些公共的需求，可动态加入）
	// 织入多个切面，可以定义切面的优先级 @order()
	@HealthCode
	@Timing
	public void shopping() {
		// 用户认证
		// 权限的鉴定
		// 日志
		// 开启事务
		// ...
		System.out.println("购物...");
		
		int t = (int) (Math.random()*1000+500);
		try {
			Thread.sleep(t);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		// 提交事务
		// 性能分析
	}
	
	@HealthCode
	@Timing
	public void subway() {
		// 日志
		// 开启事务
		System.out.println("乘地铁...");
		
		int t = (int) (Math.random()*1000+500);
		try {
			Thread.sleep(t);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		// 提交事务
		// 性能分析
	}
	
	@Timing
	public void eat() {
		System.out.println("吃饭...");
		
		int t = (int) (Math.random()*1000+500);
		try {
			Thread.sleep(t);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	// 权限验证
	@Auth(value = "admin")
	public void checkIn(String name) {
		//System.out.println("checkIn:"+name);
	}
	
	@Auth(value = "member")
	public void addOrder(int a,int b) {
	}
}
  1. Spring Main 调用测试
import org.springframework.beans.factory.BeanFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Aop0810Application {

	public static void main(String[] args) {
		SpringApplication.run(Aop0810Application.class, args);
	}

	@Bean
	public CommandLineRunner operation(BeanFactory factory) {
		
		return new CommandLineRunner() {
			
			@Override
			public void run(String... args) throws Exception {
				// 从组件工厂获得实例
				Life life = factory.getBean(Life.class);
				life.subway();
				System.out.println();
				life.shopping();
				System.out.println();
				life.eat();
				
				life.checkIn("jack");
				life.addOrder(7, 9);
			}
		};
	}
}
  1. 查看控制台输出
    在这里插入图片描述
HolyanTsao
关注
关于AOP的简单实现
weixin_43292828的博客
11-13 314
1. AOP简介 1.1什么是aop 简单来说就是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 ...
AOP简单实现（面向切面编程）
A_BCDEF_的博客
10-28 516
一、代理机制 首先简单描述一下代理机制。核心代码完成后，我们想给代码增加一些附加功能，比如日志，拦截等，这时不应该去修改核心代码，我们可以通过获取代理，在核心代码以外增加代码，实现相关功能。同样在我们没有源代码或无法触碰源代码时，也是如此。核心功能与附加功能分开，互不干扰，称之为解耦，使开发过程更加方便。 代理分为静态代理和动态代理，动态代理又有cglib代理和jdk代理之分。 1.静态代理（针对...
AOP的简单实现
weixin_34034670的博客
08-01 157
之前一篇文章分析了Java AOP的核心 - 动态代理的实现，主要是基于JDK Proxy和cglib两种不同方式。所以现在干脆把这个专题做完整，再造个简单的轮子，给出一个AOP的简单实现。这里直接使用到了cglib，这也是Spring所使用的方式。 这里是完整代码，实现总的来说比较简单，无非就是各种反射，以及cglib代理。需要说明的是...
实现一个简单的AOP
weixin_45648789的博客
04-29 887
文章目录一、AOP是什么？二、一个简单的AOP实现1.实现动态代理2.面向切面编程（这里是在添加开始和结束的时间）3.用一个工厂类将其进行初始化5.然后就是测试了6.配置文件 提示：以下是本篇文章正文内容，下面案例可供参考 一、AOP是什么？ AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的
php简单实现AOP动态代理
学无止境
04-21 858
php简单实现AOP动态代理 依赖注入 : 操作类实现一个专有接口 ,然后根据实际情况调用接口,如发送短信,发送邮件,本身都是发送,直接实现send方法,调用,我不用管里面是什么逻辑,我只要用send就可以了 控制反转 : 本来依赖注入的方法需要你自己实例化根据类型调用,现在我配置好,交给系统自动实例化调用的过程,叫控制反转 主要是为了分离关注点,比如,记录日志, 在场景用户各种的操作都需要日志,在专门的节点里面实现这个功能就可以了 下面，我们用日志服务来讲述aop的实现 代码实现地址：git clo
Asp.net Core 3.1基于AspectCore实现AOP实现事务、缓存拦截器功能
01-19
在net core2.2时，我当时就尝试过用autofac实现aop，但这次我不想用autofac，我用了一个更轻量级的框架，AspectCore。 用起来非常非常的简单，但一开始还是走了一点弯路，主要是网上都是net core3以下的教程，3以下...
利用C#实现AOP常见的几种方法详解
08-29
在C#中，实现AOP的方法多种多样，以下将详细介绍几种常见的实现方式。 1. **静态织入**： 静态织入是在编译时完成的，它通过编译器或者编译插件（如PostSharp）在目标类的代码中插入拦截逻辑。这种方式的优点是...
Spring Aop的简单实现
09-12
在本项目中，我们将探讨如何通过配置文件实现Spring AOP，包括前置通知、后置通知以及拦截器的运用。 首先，我们需要理解Spring AOP的核心概念。切面（Aspect）是关注点的模块化，这些关注点定义了跨越多个对象的...
手写简单实现ioc、aop事务demo
10-19
在Java中，JDK动态代理或CGLIB可以用来实现AOP。 在这个示例中，我们将利用动态代理来处理事务。首先，我们需要定义一个`Transaction`接口，包含开启、提交和回滚事务的方法。然后，我们可以创建一个`...
AOP简单实现
01-17
一个简单的AOP例子，同时也是log4j的简单使用DEMO
AOP编程的简单实现
weixin_43360488的博客
11-22 180
AOP是什么 AOP是一种编程范式，提供从还有一个角度来考虑程序结构以完好面向对象编程（OOP）。 AOP为开发人员提供了一种描写叙述横切关注点的机制，并可以自己主动将横切关注点织入到面向对象的软件系统中。从而实现了横切关注点的模块化。 AOP可以将那些与业务无关，却为业务模块所共同调用的逻辑或责任。比如事务处理、日志管理、权限控制等。封装起来，便于降低系统的反复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。 AOP能干什么，也是AOP带来的优点 减少模块的耦合度 使系统easy扩展 设计决.
实现简单的Aop
qq_30761967的博客
05-23 142
使用jdk的动态代理 创建Custom接口和实现类 public interface Custom { public void NeedApple(); public void NeedPen(); } public class CustomImpl implements Custom { @Override public void NeedApple() { ...
实现简单AOP
qq_35598240的博客
06-08 1168
AOP都是使用设计模式的代理模式来实现的jdk的是通过动态代理 且目标类必须有接口为啥要有接口 https://blog.csdn.net/ray890206/article/details/70146029 这篇文章解释得比较简单易懂 笔者也无法分析好 所以建议还是百度一下 当然最后会有自己的看法现在先来实现JDK 的动态代理首先是需要被增强的目标类与目标类的接口public interface...
如何简单的实现 AOP
热门推荐
INotWant的博客
05-20 1万+
AOP 1. aop 简介 1.1 什么是 aop AOP （Aspect Oriented Programming，面向切面编程），可以在运行时动态地将代码切入到类中指定方法、指定位置上的一种技术。说白了，就是把 横切逻辑 从 业务逻辑 中抽离出来。哪些属于 横切逻辑 呢？比如，性能监控、日志、事务管理、权限控制等等。 1.2 aop 综述 更详细的介绍请参考（Spri...
Spring Aop（简单实现）
zh1685188342的博客
06-13 112
spring aop环绕通知简单实现步骤 1、创建一个代理类，加上@Aspect注解 2、定义一种通知
Java动态代理实现AOP原理与实践
"本文主要探讨如何使用动态代理实现AOP（面向切面编程），并以Spring AOP为例进行详细解释。我们将通过一个简单的示例来理解动态代理在AOP中的应用，以及它如何帮助我们避免代码重复，提高代码的可维护性和可扩展性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值