6.spring:AOP(注解）
spring Aop
AOP面向切面编程，与OOP面向对象编程相辅相成
AOP中最基本的单元是切面
问题：
代码混乱：越来越多的业务需求（日志&验证）加入后，原有的业务方法急剧膨胀，每个方法在处理核心代码的同时还必须兼顾其他的多个关注点
代码分散，以日志为例，知识为了满足这一单一的需求，就不得不在代码块中里多次调用重复的日志代码，如果日志发生变化，必须修改所有的模块
简介：
AOP:面向切面编程，是一种新的方法，式传统OOP面向对象编程的补充
AOP主要编程对象是切面，而切面模块化横切的关注点
在应用AOP编程时，仍需要定义公共的功能，但可以明确定义的功能在哪，以什么方式应用，并且不必修改影响的类，这样横切关注点就被模块化到特殊的
对象（切面）里
AOP的好处：
->每个事物逻辑位于一个位置，代码不分散，便于维护
->业务模块化更简洁，只包含核心的业务代码
AOP术语：
切面（Aspect）：横切关注点被模块化的特殊对象
通知（Advice）：切换必须完成的工作
目标（Target）：被通知的对象
代理（Proxy）：向目标对象应用的通知之后创建的对象
连接点（Joinpoint）：程序执行的特定位置
切点（pointcut）：每个类都有若干个连接点，
AOP即使通过定位到特定的连接点
每次做方法的时候，都在执行之前和之后都有相关的打印操作！
AtithmeticCalculator.java
public interface AtithmeticCalculator { int add(int i,int j); int sub(int i,int j); int mul(int i,int j); int div(int i,int j); }
AtithmeticCalculatorImp.java
接口中方法的实现。
@Component public class AtithmeticCalculatorImp implements AtithmeticCalculator{ public int add(int i, int j) { int res = i + j; return res; } public int sub(int i, int j) { int res = i - j; return res; } public int mul(int i, int j) { int res = i * j; return res; } public int div(int i, int j) { int res = i / j; return res; } }
LoggionAspect.java
切面类
//把这个类升级称为一个切面：返给到IOC容器中---->在声明为一个注解
@Order(2) @Aspect @Component public class LoggionAspect { @Before("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))") public void beforeMethod(JoinPoint joinPoint){ String methodName = joinPoint.getSignature().getName(); Object [] args = joinPoint.getArgs(); System.out.println("The method " + methodName + " begins with " + Arrays.asList(args)); } /** * 在方法执行之后执行的代码. 无论该方法是否出现异常 */ @After("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))") public void afterMethod(JoinPoint joinPoint){ String methodName = joinPoint.getSignature().getName(); System.out.println("The method " + methodName + " ends"); } /** * 在方法法正常结束受执行的代码 * 返回通知是可以访问到方法的返回值的! */ @AfterReturning(value="execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))", returning="result") public void afterReturning(JoinPoint joinPoint, Object result){ String methodName = joinPoint.getSignature().getName(); System.out.println("The method " + methodName + " ends with " + result); } /** * 在目标方法出现异常时会执行的代码. * 可以访问到异常对象; 且可以指定在出现特定异常时在执行通知代码 */ @AfterThrowing(value="execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))",throwing="e") public void afterThrowing(JoinPoint joinPoint, Exception e){ String methodName = joinPoint.getSignature().getName(); System.out.println("The method " + methodName + " occurs excetion:" + e); } //环绕通知 //需要携带ProceedingJoinPoint这个类型的参数 //环绕通知类似动态代理的全类名：ProceedingJoinPoint可以绝对是否执行目标方法 //必须要有返回值，返回值即为目标方法的返回值 // @Around("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))") // public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint){ // System.out.println("@Around"); // //返回值 // Object result = null; // //前置通知 // String methodName = proceedingJoinPoint.getSignature().getName(); // try { // //前置通知 // System.out.println("The methodName:" + methodName + " _The args :" + Arrays.asList(proceedingJoinPoint.getArgs())); // //执行目标方法 // result = proceedingJoinPoint.proceed(); // //后置通知 // System.out.println("End result:" + result); // } catch (Throwable e) { // //e.printStackTrace(); // //异常通知 // System.out.println("Exception:" + e); // } // //后置通知 // System.out.println("End..."); // //返回值 // return result; // } }
LoggionAspect2.java
切面类2//把这个类升级称为一个切面：返给到IOC容器中---->在声明为一个注解
@Order(1) @Aspect @Component public class LoggionAspect2 { //定义一个方法用于切点表达式 //一般的该方法不需要填入其他的代码 @Pointcut("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))") public void declareJointPointExpression(){ }
@Before("declareJointPointExpression()") public void beforeMethod1(JoinPoint joinPoint){ System.out.println("--->beforeMethod1"); String methodName = joinPoint.getSignature().getName(); Object [] args = joinPoint.getArgs(); System.out.println("The method " + methodName + " begins with " + Arrays.asList(args)); System.out.println("--->beforeMethod1"); } /** * 在方法执行之后执行的代码. 无论该方法是否出现异常 */ @After("declareJointPointExpression()") public void afterMethod1(JoinPoint joinPoint){ String methodName = joinPoint.getSignature().getName(); System.out.println("The method " + methodName + " ends"); } /** * 在方法法正常结束受执行的代码 * 返回通知是可以访问到方法的返回值的! */ @AfterReturning(value="declareJointPointExpression())", returning="result") public void afterReturning1(JoinPoint joinPoint, Object result){ String methodName = joinPoint.getSignature().getName(); System.out.println("The method " + methodName + " ends with " + result); } /** * 在目标方法出现异常时会执行的代码. * 可以访问到异常对象; 且可以指定在出现特定异常时在执行通知代码 */ @AfterThrowing(value="declareJointPointExpression()",throwing="e") public void afterThrowing1(JoinPoint joinPoint, Exception e){ String methodName = joinPoint.getSignature().getName(); System.out.println("The method " + methodName + " occurs excetion:" + e); } //环绕通知 //需要携带ProceedingJoinPoint这个类型的参数 //环绕通知类似动态代理的全类名：ProceedingJoinPoint可以绝对是否执行目标方法 //必须要有返回值，返回值即为目标方法的返回值 // @Around("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))") // public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint){ // System.out.println("@Around"); // //返回值 // Object result = null; // //前置通知 // String methodName = proceedingJoinPoint.getSignature().getName(); // try { // //前置通知 // System.out.println("The methodName:" + methodName + " _The args :" + Arrays.asList(proceedingJoinPoint.getArgs())); // //执行目标方法 // result = proceedingJoinPoint.proceed(); // //后置通知 // System.out.println("End result:" + result); // } catch (Throwable e) { // //e.printStackTrace(); // //异常通知 // System.out.println("Exception:" + e); // } // //后置通知 // System.out.println("End..."); // //返回值 // return result; // } }
applicationContext.xml
<!-- 配置自动扫描的包 --> <context:component-scan base-package="com.MrChengsc.AOP"></context:component-scan> <!-- 前置通知，使切面里的注解起作用 --> <!-- 使AspectJ注解起作用：自动为匹配的类生成代理效果 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
main:
public static void main(String[] args) { // AtithmeticCalculator atithmeticCalculator = null; // atithmeticCalculator = new AtithmeticCalculatorImp(); // // atithmeticCalculator.add(1, 3); // System.out.println("---"); // atithmeticCalculator.sub(3, 1); // System.out.println("---"); // atithmeticCalculator.mul(1, 3); // System.out.println("---"); // atithmeticCalculator.div(10, 2); // System.out.println("---"); ApplicationContext ctx = new ClassPathXmlApplicationContext("AOPContext.xml"); //强制的类型使用接口的类型 AtithmeticCalculator atithmeticCalculator = (AtithmeticCalculator) ctx.getBean(AtithmeticCalculator.class); int res = atithmeticCalculator.add(3, 6); System.out.println("res:" + res); System.out.println("-----"); // int res1 = atithmeticCalculator.mul(2, 3); // System.out.println("res1:" + res1); //异常代码的测试 // int res2 = atithmeticCalculator.div(10, 0); // System.out.println("res2:" + res2); }
执行的顺序以及结果：
--->beforeMethod1 The method add begins with [3, 6] --->beforeMethod1 The method add begins with [3, 6] The method add ends The method add ends with 9 The method add ends The method add ends with 9 res:9 -----
注：
1.首先需要在xml文件中进行包的扫描<context:component-scan>
2.使切面的注解起作用：<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
3.使用@Component在要进行处理的类、切面类上
4.使用@Aspect进行标注切面类
5.使用 @Before()在方法上作为前置通知
6. 使用@After()在方法上作为后置通知，无论该方法是否出现异常
7. 使用@AfterReturning（value="",returning=""）,正常结束后那倒返回值
8.使用 @AfterThrowing（value="",throwing=""）,在执行发生异常时，那倒异常信息
9.使用@Around（）作为环绕通知，使用比较少
10.使用@Pointcut（）放在空方法上，作为切点表达式，引用切点直接使用方法名
11.使用@Order(1)放在类上指定切面的优先级，数值越小优先级越高
12.@After("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))")
*：代表所有，任意的
..：代表任意的形参
AOP的实现都有这个符号！
