spring之AOP（面向切面编程）

一、简介

何为AOP，通俗的将就是给某些方法执行之前、执行之后等动作发生的时候执行某些操作，在执行这些操作的时候可以获取执行方法的相关信息，简化程序开发中总是重复的东西，比如方法入参出参的日志打印，用户访问权限校验，事务控制等。

二、术语

通知（advice）:切面的工作被称为通知。通俗点：什么时候怎么干啥事。

1.前置通知（before）：在目标方法被调用之前调用通知功能。

2.后置通知（after）:在目标方法完成之后调用通知，此事不会关心方法的输出是什么。

3.返回通知（after-returning）：在目标方法成功执行之后调用通知。

4.异常通知（after-throwing）:在目标方法跑出异常后调用通知。

5.环绕通知（around）:通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

连接点（joinpoint）:使用通知的地方。

切点（pointcut）:匹配通知所要织入的一个或多个连接点。

切面（aspect）:通知和切点的结合定义切面的全部内容，它是什么，在何时何处完成其功能。

引入（introduction）:可以向现有的类添加新方法和属性。

织入（weaving）:把切面应用到目标对象并创建新的代理对象的过程。切面在制定的连接点被织入到目标对象中，在目标对象的生命周期里有多个点可以织入：

1.编译期：切面在目标类编译时织入，这种方式需要特殊的编译器，AspectJ的织入编辑器就是以这种方式织入切面的。

2.类加载期：切面在目标类加载到JVM时织入，这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增强该目标类的字节码。

3.运行期：切面在应用运行的某个时刻被织入，一般情况下，在织入切面时，AOP容器会为目标对象动态的创建一个代理对象，SpringAOP就是以这种方式织入切面的。

三、spring对AOP的支持

spring提供了4种类型的AOP支持：

1.基于代理的经典SpringAOP

2.纯POJO切面

3.@AspectJ注解驱动的切面

4.注入式AspectJ切面

前三种是springAOP实现的变体，SpringAOP构建在动态代理的基础之上，因此，spring对AOP的支持局限于方法拦截。

四、spring只支持方法界别的连接点

因为spring是基于动态代理，所以孩子恩能够支持方法级别的aop。AspectJ和JBoss,除了方法切点，还提供了字段和构造器接入点。spring缺少字段连接点的支持，无法让我们创建细粒度的通知，例如拦截对象字段的修改，而且他不支持构造器连接点，我们就无法再bean创建时应用通知。

五、切点表达式

execution(* sundsystem.CompactDisc.playTrack(int))

第一个* 返回任意类型

sundsystem.CompactDisc 方法所属的类型

playTrack 方法

int 接受int类型的参数

六、demo

注解：

package com.pz.aop;

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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;

@Aspect
@Component
public class LogAspect {

	private static Logger logger = LoggerFactory.getLogger(LogAspect.class);
	
	@Pointcut("execution(public * com.pz.service..*.*(..))")
	public void logPoint(){}
	
	@Before("logPoint()")
	public void logBefor(JoinPoint joinPoint){
		String method = joinPoint.getSignature().getName();
		Object [] args = joinPoint.getArgs();
		String param = JSON.toJSONString(args);
		logger.info("[前置通知][{}] param:{}", method, param);
	}
	
	@After("logPoint()")
	public void logAfter(JoinPoint joinPoint){
		String method = joinPoint.getSignature().getName();
		Object [] args = joinPoint.getArgs();
		String param = JSON.toJSONString(args);
		logger.info("[后置通知][{}] result:{}", method, param);
	}
	
	@AfterReturning(pointcut="logPoint()", returning="result")
	public void logAfterReturning(JoinPoint joinPoint, Object result){
		String method = joinPoint.getSignature().getName();
		String response = JSON.toJSONString(result);
		logger.info("[返回通知][{}] return:{}", method, response);
	}
	
	@AfterThrowing(pointcut="logPoint()", throwing="e")
	public void logAfterThrowing(JoinPoint joinPoint, Exception e){
		String method = joinPoint.getSignature().getName();
		logger.error("[异常通知][{}] exception:{}", method, e.getMessage());
	}
	
	@Around("logPoint()")
	public Object logArount(ProceedingJoinPoint pjp) throws Throwable{
		Object result = null;
		String param = JSON.toJSONString(pjp.getArgs());
		String method = pjp.getSignature().getName();
		try{
			logger.info("[环绕通知][{}] param:{}", method, param);
			result = pjp.proceed();
			logger.info("[环绕通知][{}] result:{}", method, JSON.toJSON(result));
		}catch(Exception e){
			logger.error("[环绕通知][{}] exception:{}", method, e.getMessage());
			 throw new RuntimeException(e);
		}
		logger.info("[环绕通知][{}] return:{}", method, JSON.toJSON(result));
		return result;
	}

}

来源：oschina

链接：https://my.oschina.net/u/2363714/blog/812506

标签

aop

切面

spring自定义注解