spring学习总结(九)：AOP 基础及基于注解配置的AOP

AOP 前奏

代码实现

Calculator.java

public interface Calculator {

int add(int i, int j);

int sub(int i, int j);

int mul(int i, int j);

int div(int i, int j);

}

CalculatorLogger.java

public class CalculatorLogger implements Calculator {

@Override
public int add(int i, int j) {
System.out.println("The method add with ["+i+" , "+j+"]");

int result = i + j;
System.out.println("The method add ends with"+ result);

return result;
}

@Override
public int sub(int i, int j) {
System.out.println("The method sub with ["+i+" , "+j+"]");

int result = i - j;
System.out.println("The method sub ends with"+ result);

return result;
}

@Override
public int mul(int i, int j) {
System.out.println("The method mul with ["+i+" , "+j+"]");

int result = i * j;
System.out.println("The method mul ends with"+ result);

return result;

}

@Override
public int div(int i, int j) {
System.out.println("The method div with ["+i+" , "+j+"]");

int result = i / j;
System.out.println("The method div ends with"+ result);

return result;
}

}

ApplicationBasic.java

public class ApplicationBasic {

public static void main(String[] args) {

Calculator calculator = null;

calculator = new CalculatorLogger();

int result = calculator.add(3, 2);
System.out.println("-->"+result);

result = calculator.div(9, 3);
System.out.println("-->"+result);

}
}

测试结果：



上述实现问题：

代码混乱：越来越多的非业务需求(日志和验证等)加入后,原有的业务方法急剧膨胀.  每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点. 
代码分散: 以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块（方法）里多次重复相同的日志代码.如果日志需求发生变化, 必须修改所有模块.

使用动态代理解决上述问题

代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上.

代码实现：

CalculatorLogger.java

public class CalculatorLogger implements Calculator {

@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;
}

}

CalculatorLoggerProxy.java

/**
*
* @ClassName:  CalculatorLoggerProxy
* @Description:动态代理实现AOP
* @author: xyc
* @date:   2016年12月24日 下午8:25:01
*
*/
public class CalculatorLoggerProxy {

//要代理的对象
private Calculator target;

public CalculatorLoggerProxy(Calculator target) {
this.target = target;
}

public Calculator getLoggerProxy(){
Calculator proxy = null;

//打理对象由哪一个类加载器加载
ClassLoader loader = target.getClass().getClassLoader();
//代理对象的类型，即其中有那些方法
Class[] interfaces = new Class[]{Calculator.class};

//当调用代理对象其中的方法时，该执行的代码
InvocationHandler h = new InvocationHandler() {
/**
*
* <p>Title: invoke</p>
* <p>Description: </p>
* @param proxy 正在返回的那个代理对象，一般情况下，在invoke方法中不使用该对象
* @param method 正在被调用的那个方法
* @param args  调用方法时，传递的参数
* @return
* @throws Throwable
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

String methodName = method.getName();

//执行方法
Object result = null ;
try {
//前置通知
System.out.println("The method "+methodName+" with "+Arrays.asList(args));
result = method.invoke(target, args);
//返回通知
} catch (Exception e) {
//异常通知
}
//后置通知
System.out.println("The method "+result+" ends with"+ result);

return result;
}
};
proxy = (Calculator) Proxy.newProxyInstance(loader, interfaces, h);

return proxy;
}
}

ApplicationProxy.java

public class ApplicationProxy {

public static void main(String[] args) {

CalculatorLogger calculatorLogger = new CalculatorLogger();

Calculator proxy = new CalculatorLoggerProxy(calculatorLogger).getLoggerProxy();

int result = proxy.add(3, 2);
System.out.println("-->"+result);

result = proxy.div(9, 3);
System.out.println("-->"+result);

}
}

测试结果：



好了，说了这么多，到底什么是Aop?

AOP简介

AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充.
AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.
在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用,并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.

AOP 的好处:

每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级
业务模块更简洁, 只包含核心业务代码.

AOP 术语

切面(Aspect):  横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象      上述图中业务逻辑模块一个个具体
通知(Advice):  切面必须要完成的工作，切面中的每一个方法称为通知
目标(Target): 被通知的对象
代理(Proxy): 向目标对象应用通知之后创建的对象
连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 ArithmethicCalculator#add() 方法执行前的连接点，执行点为 ArithmethicCalculator#add()； 方位为该方法执行前的位置
切点（pointcut）：每个类都拥有多个连接点：例如 ArithmethicCalculator 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

Spring  AOP

AspectJ：Java 社区里最完整最流行的 AOP 框架.
在 Spring2.0 以上版本中, 可以使用基于 AspectJ 注解或基于 XML 配置的 AOP
AspectJ 支持 5 种类型的通知注解: 

@Before: 前置通知, 在方法执行之前执行
@After: 后置通知, 在方法执行之后执行 
@AfterRunning: 返回通知, 在方法返回结果之后执行
@AfterThrowing: 异常通知, 在方法抛出异常之后
@Around: 环绕通知, 围绕着方法执行

在 Spring 中启用 AspectJ 注解支持

①.引入依赖

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.2.RELEASE<version>
</dependency>

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.6.11</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.11</version>
</dependency>

②要在 Spring IOC 容器中启用 AspectJ 注解支持, 只要在 Bean 配置文件中定义一个空的 XML 元素 <aop:aspectj-autoproxy>  当 Spring IOC 容器侦测到 Bean 配置文件中的 <aop:aspectj-autoproxy> 元素时, 会自动为与 AspectJ 切面匹配的 Bean 创建代理.

③.在切面类中使用@Aspect，然后在类中声明各种通知

④.可以在通知方法中声明一个类型为JoinPoint的参数，然后就能访问链接明细，如方法名称和参数

⑤.切入点表达式根据方法的签名来匹配各种方法（execution(* com.xyc.spring.aop.CalculatorLogger.*(..) ）   第一个 * 代表任意修饰符及任意返回值. 第二个 * 代表任意方法. .. 匹配任意数量的参数

⑥.在 AspectJ 中, 切入点表达式可以通过操作符 &&, ||, ! 结合起来. （execution(* com.xyc.spring.aop.CalculatorLogger.add(..)  ||  execution(* com.xyc.spring.aop.CalculatorLogger.div(..)）

前置通知:

前置通知:在方法执行之前执行的通知
前置通知使用 @Before 注解, 并将切入点表达式的值作为注解值.

/**
*
* @ClassName:  LoggerAspectJ
* @Description:把这个类声明为一个切面：需要先将该类放入到IOC容器中，然后在声明为切面
* @author: xyc
* @date:   2016年12月24日 下午6:04:05
*
*/
@Component
@Aspect
public class LoggerAspectJ {
/**
*
* @Title: beforeMethod
* @Description: 声明该方法是一个前置通知：在目标方法之前执行
* @param: @param joinPoint
* @return: void
* @throws
*/
@Before("execution(* com.xyc.spring.aop.Calculator.*(..))")
public void beforeMethod(JoinPoint joinPoint){
System.out.println("This is 前置通知");
}
}

后置通知:

后置通知是在连接点完成之后执行的, 即连接点返回结果或者抛出异常的时候, 下面的后置通知记录了方法的终止. 
一个切面可以包括一个或者多个通知.

/**
*
* @ClassName:  LoggerAspectJ
* @Description:把这个类声明为一个切面：需要先将该类放入到IOC容器中，然后在声明为切面
* @author: xyc
* @date:   2016年12月24日 下午6:04:05
*
*/
@Component
@Aspect
public class LoggerAspectJ {
/**
*
* @Title: afterMethod
* @Description: 后置通知：在目标方法执行后执行(无论执行目标方法过程中是否发生异常都会执行)，执行的通知
* @param: @param joinPoint
* @return: void
* @throws
*/
@After("execution(* com.xyc.spring.aop.Calculator.*(..))")
public void afterMethod(JoinPoint joinPoint){
System.out.println("This is 后置通知");
}
}

返回通知：

无论连接点是正常返回还是抛出异常, 后置通知都会执行. 如果只想在连接点返回的时候记录日志, 应使用返回通知代替后置通知.
在返回通知中, 只要将 returning 属性添加到 @AfterReturning 注解中, 就可以访问连接点的返回值. 该属性的值即为用来传入返回值的参数名称. 
必须在通知方法的签名中添加一个同名参数. 在运行时, Spring AOP 会通过这个参数传递返回值.
原始的切点表达式需要出现在 pointcut 属性中

/**
*
* @Title: afterReturning
* @Description: 在方法正常结束后执行的代码  返回通知是可以访问到方法的返回值的
* @param: @param joinPoint
* @param: @param result
* @return: void
* @throws
*/
@AfterReturning(value="execution(* com.xyc.spring.aop.Calculator.*(..))",returning="result")
public void afterReturning(JoinPoint joinPoint,Object result){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" result "+result);
}

异常通知：

只在连接点抛出异常时才执行异常通知
将 throwing 属性添加到 @AfterThrowing 注解中, 也可以访问连接点抛出的异常. Throwable 是所有错误和异常类的超类. 所以在异常通知方法可以捕获到任何错误和异常.
如果只对某种特殊的异常类型感兴趣, 可以将参数声明为其他异常的参数类型. 然后通知就只在抛出这个类型及其子类的异常时才被执行.

/**
*
* @Title: afterThrowing
* @Description: 在目标方法出现异常时会执行的代码   可以访问到异常对象，切可以指定在出现特定异常时再执行通知代码
* @param: @param joinPoint
* @param: @param e
* @return: void
* @throws
*/
@AfterThrowing(value="execution(* com.xyc.spring.aop.Calculator.*(..))",throwing="e")
public void afterThrowing(JoinPoint joinPoint,Exception e){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" Exception "+e);
}

环绕通知：

环绕通知是所有通知类型中功能最为强大的, 能够全面地控制连接点. 甚至可以控制是否执行连接点.
对于环绕通知来说, 连接点的参数类型必须是 ProceedingJoinPoint . 它是 JoinPoint 的子接口, 允许控制何时执行, 是否执行连接点.
在环绕通知中需要明确调用 ProceedingJoinPoint 的 proceed() 方法来执行被代理的方法. 如果忘记这样做就会导致通知被执行了, 但目标方法没有被执行.
注意: 环绕通知的方法需要返回目标方法执行之后的结果, 即调用 joinPoint.proceed(); 的返回值, 否则会出现空指针异常

/**
*
* @Title: around
* @Description:  环绕通知需要携带 ProceedingJoinPoint 类型的参数
* 环绕通知类似于动态代理的全过程，ProceedingJoinPoint 类型的参数可以决定是否执行目标方法.
* 且环绕通知必须有返回值，返回值即为目标方法的返回值
* @param: @param pjp
* @param: @return
* @return: Object
* @throws
*/
@Around("execution(* com.xyc.spring.aop.Calculator.*(..))")
public Object around(ProceedingJoinPoint pjp){

Object result = null;
String methodName = pjp.getSignature().getName();

try {
//前置通知、
System.out.println("The method "+methodName+" with "+Arrays.asList(pjp.getArgs()));
//执行目标方法
result = pjp.proceed();
//返回通知
System.out.println("The method "+methodName+" result "+result);
} catch (Throwable e) {
//异常通知
System.out.println("The method "+methodName+" Exception "+e);
throw new RuntimeException(e);
}
//后置通知
System.out.println("The method "+methodName+" end ");
return result;
}

AOP实现前奏需求：

LoggerAspectJ.java

package com.xyc.spring.aop;

import java.util.Arrays;
import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
*
* @ClassName:  LoggerAspectJ
* @Description:把这个类声明为一个切面：需要先将该类放入到IOC容器中，然后在声明为切面
* @author: xyc
* @date:   2016年12月24日 下午6:04:05
*
*/
@Component
@Aspect
public class LoggerAspectJ {

/**
*
* @Title: beforeMethod
* @Description: 声明该方法是一个前置通知：在目标方法之前执行
* @param: @param joinPoint
* @return: void
* @throws
*/
@Before("execution(* com.xyc.spring.aop.Calculator.*(int, int))")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+" with "+args);
}

/**
*
* @Title: afterMethod
* @Description: 后置通知：在目标方法执行后执行(无论执行目标方法过程中是否发生异常都会执行)，执行的通知
* @param: @param joinPoint
* @return: void
* @throws
*/
@After("execution(* com.xyc.spring.aop.Calculator.*(int, int))")
public void afterMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
//在后置通知中不能访问目标方法执行的结果
System.out.println("The method "+methodName+" end ");
}
}

ApplicationAop.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd"> 
<!-- 配置自动扫描包 -->
<context:component-scan base-package="com.xyc.spring.aop"></context:component-scan>

<!-- 使用aspectj注解起作用：自动为匹配的类生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

ApplicationAop.java

/**
*
* @ClassName:  ApplicationAop
* @Description:测试AOP
* @author: xyc
* @date:   2016年12月24日 下午6:12:59
*
*/
public class ApplicationAop {

public static void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationAop.xml");

Calculator bean = context.getBean(Calculator.class);

int result = bean.add(3, 2);
System.out.println("-->"+result);

result = bean.div(9, 3);
System.out.println("-->"+result);
}
}

测试结果：

切面的优先级

在同一个连接点上应用不止一个切面时, 除非明确指定, 否则它们的优先级是不确定的.
切面的优先级可以通过实现 Ordered 接口或利用 @Order 注解指定.
实现 Ordered 接口, getOrder() 方法的返回值越小, 优先级越高.
若使用 @Order 注解, 序号出现在注解中

@Order(2)
@Aspect
@Component
public class LoggerAspectJ {}

@Order(1)
@Aspect
@Component
public class ViladationAspectj {}

重用切入点定义

在编写 AspectJ 切面时, 可以直接在通知注解中书写切入点表达式. 但同一个切点表达式可能会在多个通知中重复出现.
在 AspectJ 切面中, 可以通过 @Pointcut 注解将一个切入点声明成简单的方法. 切入点的方法体通常是空的, 因为将切入点定义与应用程序逻辑混在一起是不合理的. 
切入点方法的访问控制符同时也控制着这个切入点的可见性. 如果切入点要在多个切面中共用, 最好将它们集中在一个公共的类中. 在这种情况下, 它们必须被声明为 public. 在引入这个切入点时, 必须将类名也包括在内. 如果类没有与这个切面放在同一个包中, 还必须包含包名.
其他通知可以通过方法名称引入该切入点.
同一个类中，只需要引入方法名称.

/**
*
* @Title: declareJoinPointExpression
* @Description: 定义一个方法，声明切入点表达式，该方法不需要其他代码
* @param:
* @return: void
* @throws
*/
@Pointcut("execution(* com.xyc.spring.aop.Calculator.*(..))")
public void declareJoinPointExpression(){}

@Before("declareJoinPointExpression()")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+" with "+args);
}

同包不同类中，需要类名.方法

@Before("LoggerAspectJ.declareJoinPointExpression()")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("--->ViladationAspectj "+methodName+" with "+args);
}

不同包下，需要全类名.方法

@Before("com.xyc.spring.aop.LoggerAspectJ.declareJoinPointExpression()")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("--->ViladationAspectj "+methodName+" with "+args);
}