AOP面向切面编程
AOP(Aspect-Oriented Programming,面向切面编程):是一种新的方法论,是对传统OOP(Object-Oriented Programming,面向对象编程)的补充。
AOP编程时,仍然需要定义公共功能,但可以明确的定义这个功能在哪里,以什么方式应用,并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的对象(切面)里(aspect).
AOP的好处:
每个事物逻辑位于一个位置,代码不分散,便于维护和升级
业务模块更简洁,只包含核心业务代码
横切关注点:
会出现如下的问题:
1.代码混乱:越来越多的非业务需求(日志和验证等)加入后,原有的业务方法几句膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点
2.代码分散:以日志需求为例,只是为了满足这个单一需求,就不得不在多个模块(方法)里多次重复相同的日志代码。如果日志需求发生变化,必须修改所有模块。
其中可以同过使用动态代理解决问题:
代理设计模式的原理:使用一个代理将对象包装起来,然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
AOP面向切面编程的使用:
用Aspect注解声明切面
切面:带有@Aspect注解的java类
通知:是标注有以下5种注解的简单的java方法
@Before:前置通知,在方法执行之前执行
@After:后置通知,在方法执行之后执行
@AfterRunning:返回通知,在方法返回结果之后执行
@AfterThrowing:异常通知,在方法抛出异常之后
@Around:环绕通知,围绕着方法执行
AOP的流程:
1.导入包(四个)
2.在XML中配置文件(AOP的命名空间)、扫描包、自动代理(使@Aspect注解发挥作用)
3.在切面类上加@Aspect注解
4.java方法上加5种注解(其中的一种)
利用方法签名编写Aspect切入点表达式:
例如:
加减乘除方法的AOP应用实例:
在applicationContext-aop.xml中配置信息
<!-- 自动扫描 -->
<context:component-scan base-package="com.jredu.aop">
</context:component-scan>
<!-- AOP的自动代理:使aspect注解发挥作用 -->
<aop:aspectj-autoproxy>
</aop:aspectj-autoproxy>
算法接口:
package com.jredu.aop.service;
public interface ArithmeticCalculator {
double add(double a,double b);
double sub(double a,double b);
double mul(double a,double b);
double div(double a,double b);
}
算法接口的实现类:
package com.jredu.aop.service.impl;
import org.springframework.stereotype.Component;
import com.jredu.aop.service.ArithmeticCalculator;
@Component("arith")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
@Override
public double add(double a, double b) {
// TODO Auto-generated method stub
System.out.println("=====================");
return a+b;
}
@Override
public double sub(double a, double b) {
// TODO Auto-generated method stub
return a-b;
}
@Override
public double mul(double a, double b) {
// TODO Auto-generated method stub
return a*b;
}
@Override
public double div(double a, double b) {
// TODO Auto-generated method stub
return a/b;
}
}
切面(5中实现方式)
package com.jredu.aop.aspect;
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.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* 切面
* @author Administrator
*
*/
@Aspect
@Component
@Order(1)//优先级:数值越小优先级越高
public class LogAspect {
/**
* 切面的方法:匹配com.jredu.aop.service的所有接口或类,当中至少包含一个double类型参数的sub方法
* @param point
*/
@Before("execution(public double com.jredu.aop.service.*.*(double,..))")
public void test(JoinPoint point){
String methodName=point.getSignature().getName();
double a = (double) point.getArgs()[0];
System.out.println("有一个double类型参数的方法:"+methodName+"的double类型参数a="+a);
}
/**
* 当目标方法执行之前调用的切面方法
* @param point
*/
//前置日志
@Before("execution(public double com.jredu.aop.service.*.*(double,double))")
public void beforelog(JoinPoint point){
//方法名字
String methodName = point.getSignature().getName();
//参数列表
double a = (double) point.getArgs()[0];
double b = (double) point.getArgs()[1];
System.out.println("before----方法:"+methodName+"的参数a="+a+",b="+b);
}
//后置日志
@After("execution(public double com.jredu.aop.service.*.*(double,double))")
public void afterlog(JoinPoint point){
//方法名字
String methodName=point.getSignature().getName();
//返回结果
System.out.println("after----方法:"+methodName);
}
/**
* 当方法执行完毕并返回结果之后的切面方法
*/
@AfterReturning(pointcut="execution(* com.jredu.aop.service.*.*(..))",returning="obj")
public void afterReturning(JoinPoint point,Object obj){
//方法名
String method=point.getSignature().getName();
System.out.println("after return ----- method:"+method+",return:"+obj);
}
/**
* 当目标方法抛出异常时会执行的方法
* @param point
* @param ex
*/
@AfterThrowing(pointcut="execution(* com.jredu.aop.service.*.*(..))",throwing="ex")
public void afterThrowing(JoinPoint point,Exception ex){
String method = point.getSignature().getName();
System.out.println("after throw ----- method:"+method+",return:"+ex.getLocalizedMessage());
}
/**
* 当目标方法执行前和执行后会执行该方法(环绕方法)
* @param point
* @throws Throwable
*/
@Around("execution(* com.jredu.aop.service.*.*(..))")
public double around(ProceedingJoinPoint point) throws Throwable{
//执行目标方法前
String method = point.getSignature().getName();
System.out.println("before method:"+method);
double d= (double) point.proceed();
//执行目标方法后,返回结果前
System.out.println("返回值是:"+d);
//调用proceed方法,可以分割前后
System.out.println("after method:"+method);
return d;//最后确定要返回的值
}
}
测试类:
package com.jredu.aop.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jredu.aop.service.ArithmeticCalculator;
public class AopTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext-aop.xml");
ArithmeticCalculator calculator = (ArithmeticCalculator) app.getBean("arith");
calculator.add(5,15);
calculator.sub(5,15);
calculator.mul(5,15);
calculator.div(5,15);
}
}
指定切面的优先级:Order
在同一个连接点上应用不止一个切面时,除非明确指定,否则它们的优先级是不确定的。
切面的优先级可以通过实现Ordered接口或利用@Order注解指定。
实现Ordered接口,getOrder()方法 返回值越小,优先级越高。
若使用@Order注解,序号出现在注解中