简单实现 AOP

最新推荐文章于 2022-10-20 16:51:26 发布
最新推荐文章于 2022-10-20 16:51:26 发布
阅读量164 收藏 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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringAOP简单实现（三种实现方式）
weixin_60785926的博客
04-03 2851
AOP的三种实现方式
AOP的三种实现方式
qq_51447436的博客
02-09 5649
AOP的三种实现方式
AOP编程的简单实现
weixin_43360488的博客
11-22 141
AOP是什么 AOP是一种编程范式，提供从还有一个角度来考虑程序结构以完好面向对象编程（OOP）。 AOP为开发人员提供了一种描写叙述横切关注点的机制，并可以自己主动将横切关注点织入到面向对象的软件系统中。从而实现了横切关注点的模块化。 AOP可以将那些与业务无关，却为业务模块所共同调用的逻辑或责任。比如事务处理、日志管理、权限控制等。封装起来，便于降低系统的反复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。 AOP能干什么，也是AOP带来的优点 减少模块的耦合度 使系统easy扩展 设计决.
AOP的简单实现
weixin_34034670的博客
08-01 140
之前一篇文章分析了Java AOP的核心 - 动态代理的实现，主要是基于JDK Proxy和cglib两种不同方式。所以现在干脆把这个专题做完整，再造个简单的轮子，给出一个AOP的简单实现。这里直接使用到了cglib，这也是Spring所使用的方式。 这里是完整代码，实现总的来说比较简单，无非就是各种反射，以及cglib代理。需要说明的是...
AOP简单实现
qq_60547244的博客
10-20 333
AOP简单实现
Spring Aop的简单实现
09-12
在本项目中，我们将探讨如何通过配置文件实现Spring AOP，包括前置通知、后置通知以及拦截器的运用。 首先，我们需要理解Spring AOP的核心概念。切面（Aspect）是关注点的模块化，这些关注点定义了跨越多个对象的...
手写简单实现ioc、aop事务demo
10-19
在Java中，JDK动态代理或CGLIB可以用来实现AOP。 在这个示例中，我们将利用动态代理来处理事务。首先，我们需要定义一个`Transaction`接口，包含开启、提交和回滚事务的方法。然后，我们可以创建一个`...
SpringBoot基于注解实现Aop
03-09
Spring Boot使用CGLIB或Java代理（根据Bean是否是接口实现）来创建动态代理对象，从而实现AOP功能。如果Bean没有实现任何接口，那么Spring会使用CGLIB，否则使用Java代理。 7. **注意事项** - 切点表达式是...
SpringAOP简单项目实现
09-28
总结，这个"SpringAOP简单项目实现"涵盖了Spring AOP的基础知识，包括切面、通知、切入点的定义与配置，以及如何在实际项目中使用Maven进行构建和依赖管理。对于初学者来说，这是一个很好的实践案例，能够帮助他们...
AOP实现的三种方式
weixin_45264992的博客
04-20 7936
AOP实现的三种方式 说说为什么要使用AOP编程： AOP（面向切面编程）是OOP（面向对象编程）发展而来，在OOP编程中，每一个对象都有自己特定的功能，但是如果我们需要引入公共的功能时候，那么如果继续使用OOP编程思想的话，就会导致大量代码重用，而不利于模块的重用。而AOP编程则是将一些公共业务封装起来，为每一个需要使用这些公共业务的对象提供相应业务（通过代理实现）。一般将公共业务封装起来的类就是切面类，也就是我们切面编程所说的切面。 下面我们给对象添加一个公共业务：日志输出。 即在方法执行前后都在控制台
AOP的实现机制
执着之道
10-18 533
附件中有本文的源代码和Pdf版。本文写的很长的原因，是不希望大家学习AOP时到处找资料，大家有时间可以按照本文动手实践下，相信会有非常大的收获的，有什么问题互相交流，有问必答！ 1 AOP各种的实现     AOP就是面向切面编程，我们可以从几个层面来实现AOP。 在编译器修改源代码，在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码，以下是各种实现机制的比较。    ...
实现一个简单的AOP
weixin_45648789的博客
04-29 678
文章目录一、AOP是什么？二、一个简单的AOP实现1.实现动态代理2.面向切面编程（这里是在添加开始和结束的时间）3.用一个工厂类将其进行初始化5.然后就是测试了6.配置文件 提示：以下是本篇文章正文内容，下面案例可供参考 一、AOP是什么？ AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的
关于AOP的简单实现
weixin_43292828的博客
11-13 288
1. AOP简介 1.1什么是aop 简单来说就是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 ...
简单AOP实现过程
Thxxxxxx
06-29 479
切面类实现： @Aspect public class LogAspects { //抽取公共的切入点表达式 //1、本类引用 //2、其他的切面引用 @Pointcut("execution(public int com.atguigu.aop.MathCalculator.*(..))") public void pointCut(){}; //@Before在目标方...
一个demo简单阐述AOP实现
小小的人儿的博客
03-21 835
本demo简单实现一个切面，首先搭建一个登录的流程，然后定义一个切面对登录动作进行AOP。 Controller： @Controller @RequestMapping("/commn/*") public class LoginController { @Autowired private LoginService loginService; @Request...
spring aop的简单实现例子
Cgh_Baby的博客
03-15 402
转载请声明出处1 什么是AOP    Spring 是解决实际开发中的一些问题:    AOP 解决OOP 中遇到的一些问题.是OOP 的延续和扩展.2 为什么学习AOP对程序进行增强:不修改源码的情况下.AOP 可以进行权限校验,日志记录,性能监控,事务控制.3 Spring 的AOP 的由来:AOP 最早由AOP 联盟的组织提出的,制定了一套规范.Spring 将AOP 思想引入到框架中,必须...
实现aop
最新发布
05-24
下面是一个简单的AOP示例，假设我们有一个计算器类Calculator，其中有一个add方法： ```java public class Calculator { public int add(int a, int b) { return a + b; } } ``` 现在我们想要在add方法执行前后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值