AspectJ
2021-03-05 09:27
标签：override 类型 run eth 名称空间 class ica str 值类型 AspectJ 3) 配置 当Spring IOC容器侦测到bean配置文件中的元素时，会自动为 与AspectJ切面匹配的bean创建代理 用AspectJ注解声明切面 AspectJ 标签：override 类型 run eth 名称空间 class ica str 值类型 原文地址：https://www.cnblogs.com/lemonzhang/p/12908862.html
1、 简介
AspectJ：Java社区里最完整最流行的AOP框架。（在Spring中AOP是一种思想，而AspectJ是一种AOP的更明确具体实现）
在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。
2、在Spring中启用AspectJ注解支持
1) 导入JAR包
? com.springsource.net.sf.cglib-2.2.0.jar
? com.springsource.org.aopalliance-1.0.0.jar
? com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
? spring-aop-4.0.0.RELEASE.jar
? spring-aspects-4.0.0.RELEASE.jar
2) 引入aop名称空间
aop:aspectj-autoproxy />
1) 要在Spring中声明AspectJ切面，只需要在IOC容器中将切面声明为bean实例。
2) 当在Spring IOC容器中初始化AspectJ切面之后，Spring IOC容器就会为那些与 AspectJ切面相匹配的bean创建代理。
3) 在AspectJ注解中，切面只是一个带有@Aspect注解的Java类，它往往要包含很多通知。
4) 通知是标注有某种注解的简单的Java方法。
5) AspectJ支持5种类型的通知注解：
① @Before：前置通知，在方法执行之前执行
② @After：后置通知，在方法执行之后执行
③ @AfterRunning：返回通知，在方法返回结果之后执行
④ @AfterThrowing：异常通知，在方法抛出异常之后执行
⑤ @Around：环绕通知，围绕着方法执行package com.atguigu.spring.aop;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
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//标注当前类为切面
public class MyloggerAspect {
/**
* @Before:将方法指定为前置通知
* 必须设置value，其值为切入点表达式：找到切面作用到的连接点
* 前置通知：作用于方法执行之前
* @Before(value="execution(* com.atguigu.spring.aop.*.*(..))")
* 第一个*代表任意的访问修饰符和返回值类型
* 第二个*代表任意类
* 第三个*代表类中任意方法
* ..代表任意的参数列表
*/
@Before(value = "execution(public int com.atguigu.spring.aop.MathImpl.add(int, int))")
public void beforeMethod(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs();//获取方法的参数
String methodName = joinPoint.getSignature().getName();//获取方法名
System.out.println("method:"+methodName+",arguments:"+Arrays.toString(args));
}
/**
* @After:将方法标注为后置通知
* 后置通知：作用于方法的finally语句块，即不管有没有异常都会执行
*/
@After(value="execution(* com.atguigu.spring.aop.*.*(..))")
public void afterMethod() {
System.out.println("后置通知");
}
/**
* @AfterReturning:将方法标注为返回通知
* 返回通知：作用于方法执行之后
* 可通过returning设置接收方法返回值的变量名
* 要想在方法中使用，必须在方法的形参中设置和变量名相同的参数名的参数
*/
@AfterReturning(value="execution(* com.atguigu.spring.aop.*.*(..))", returning="result")
public void afterReturningMethod(JoinPoint joinPoint, Object result) {
String methodName = joinPoint.getSignature().getName();
System.out.println("method:"+methodName+",result:"+result);
}
/**
* @AfterThrowing:将方法标注为异常通知（例外通知）
* 异常通知（例外通知）:作用于方法抛出异常时
* 可通过throwing设置接收方法返回的异常信息
* 在参数列表中课通过具体的异常类型，来对指定的异常信息进行操作
*/
@AfterThrowing(value="execution(* com.atguigu.spring.aop.*.*(..))", throwing="ex")
public void afterThrowingMethod(ArithmeticException ex) {
System.out.println("有异常了，messages："+ex);
}
//环绕通知
@Around(value="execution(* com.atguigu.spring.aop.*.*(..))")
public Object aroundMethod(ProceedingJoinPoint joinPoint) {
Object result = null;
try {
//前置通知
System.out.println("前置通知");
result = joinPoint.proceed();//执行方法
//返回通知
System.out.println("返回通知");
return result;
} catch (Throwable e) {
// TODO Auto-generated catch block
e.printStackTrace();
//异常通知
System.out.println("异常通知");
} finally {
//后置通知
System.out.println("后置通知");
}
return -1;
}
}
package com.atguigu.spring.aop;
import org.springframework.stereotype.Component;
@Component //都应该交由Spring处理
public class MathImpl implements MathI {
@Override
public int add(int i, int j) {
int result = i + j;
return result;
}
@Override
public int sub(int i, int j) {
int result = i - j;
return result;
}
@Override
public int mul(int i, int j) {
int result = i * j;
return result;
}
@Override
public int div(int i, int j) {
int result = i / j;
return result;
}
}
package com.atguigu.spring.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("aop.xml");
MathI math = ac.getBean("mathImpl", MathI.class);
System.out.println(math.getClass().getName());
int i = math.div(4, 1);
System.out.println(i);
}
}