String AOP 面向切面编程

1、AOP

AOP，面向切面编程，AOP是一种编程思想，是对面向对象编程(OOP)的一种补充。

AOP实现分类

静态AOP实现

AOP框架在编译阶段对程序源代码进行修改，生成了静态的AOP代理类，其中，生成的.class文件已经被改掉了，需要使用特定的编译器如AspectJ。

优点：对系统无性能影响

缺点：灵活性不够

动态AOP实现

AOP框架在运行阶段对动态生成代理对象，在内存中以JDK动态代理，或CGlib动态地生成AOP代理类如SpringAOP。

2、AOP术语

• 通知：也叫，建议或者增强，AOP框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理
• 连接点：连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在SpringAOP中，连接点总是方法的调用。
• 切入点：可以插入增强处理的连接点。
• 切面：切面是通知和切点的结合。
• 引入：引入允许我们向现有的类添加新的方法或者属性
• 织入：将增强处理添加到目标对象中，并创建一个被增强的对象，这个过程就是织入。
• 目标对象(target)：真实对象的代理对象

3、SpringAOP提供的通知类型

• BeforeAdvice（前置）：目标方法调用前被调用

• AfterReturningAdvice（后置）：目标方法正常返回之后被调用

• AfterThrowingAdvice（异常）：目标方法抛出异常时调用

• AfterAdvice（最终）：无论连接点退出的方式如何（正常或者异常），均应执行通知

• AroundAdvice（环绕）：拦截对目标对象方法调用。环绕通知可以在方法调用之前和之后执行自定义行为，还负责选择是返回连接点还是通过返回其自身的返回值或引发异常来通知其他通知的方法执行。

4、通过XML配置文件声明切面

AOP常用元素

<?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:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- context:component-scan开启容器的自动扫描功能，扫描：使用@Component,@Service,@Repository,@Controller类 --><!-- base-package="" 配置扫描的基准表 --><context:component-scan base-package="com.woniuxy.springaop_xml"></context:component-scan><!-- 定义的通知 -->  <bean id="runtimeLogBeforeAdvice" class="com.woniuxy.springaop_xml.ascpets.method01.RuntimeLogBeforeAdvice"></bean> <bean id="runtimeLogAfterReturningAdvice" class="com.woniuxy.springaop_xml.ascpets.method01.RuntimeLogAfterReturningAdvice"></bean> <bean id="optLogAfterReturningAdvice" class="com.woniuxy.springaop_xml.ascpets.method01.OptLogAfterReturningAdvice"></bean> <bean id="runtimeLogAfterThrowingAdvice" class="com.woniuxy.springaop_xml.ascpets.method01.RuntimeLogAfterThrowingAdvice"></bean> <!-- 通过aop:config定义一个切面 --><aop:config><!-- execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?) --><!--  modifiers-pattern  访问修饰符--><!-- ret-type-pattern 返回类型 --><!-- declaring-type-pattern 类的类路径 --><!-- name-pattern(param-pattern) 类的方法名以及参数列表 --><!-- throws-pattern 抛出异常 --><aop:pointcut expression="execution(* com.woniuxy.springaop_xml.*mag.service.impl.*ServiceImpl.*(..))" id="runtimeLogPointCut"></aop:pointcut><!-- 将通知与切入点 连接起来 --><aop:advisor advice-ref="runtimeLogBeforeAdvice" pointcut-ref="runtimeLogPointCut"/><aop:advisor advice-ref="runtimeLogAfterReturningAdvice" pointcut-ref="runtimeLogPointCut"/><aop:advisor advice-ref="optLogAfterReturningAdvice" pointcut-ref="runtimeLogPointCut"/><aop:advisor advice-ref="runtimeLogAfterThrowingAdvice" pointcut-ref="runtimeLog"/></aop:config></beans>`

5、通过注解配置文件声明切面

@Aspect

• 前置通知

• 后置返回通知

• 后置异常通知

• 后置通知

• 环绕通知

具体实现步骤：

1、在applicationContext.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:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- context:component-scan开启容器的自动扫描功能，扫描：使用@Component,@Service,@Repository,@Controller类 --><!-- base-package="" 配置扫描的基准表 --><context:component-scan base-package="com.woniuxy.springaop_anno"></context:component-scan><!-- 开启切面的代理支持 --><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>

2、使用@Aspect定义切面类

tips：

​ （1）@Aspect表示该Java类是一个切面类
​ （2）@Component 表示将切面类交给IOC容器

3、在切面上定义通知

（1）先定义切入点表达式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-POSyiwSW-1594181923963)(C:\Users\飞鱼\AppData\Roaming\Typora\typora-user-images\image-20200702195413784.png)]

表达式的格式：

​ execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

• modifiers-pattern：访问修饰符

• ret-type-pattern ：返回类型

• declaring-type-pattern：类的类路径

• name-pattern(param-pattern)：类的方法名以及参数列表

• throws-pattern：抛出异常

（2）定义通知

前置通知

/*** * @Title: beforeAdvice* @Description: 前置通知，运行在目标方法执行之前* @param: @param joinPoint 参数说明* @return: void 返回类型* @throws*/@Before("pointcut()")public void beforeAdvice(JoinPoint joinPoint) {//目标对象Object target = joinPoint.getTarget();//获得目标方法的方法名String methodName = joinPoint.getSignature().getName();//获得方法正在使用的参数Object[] args = joinPoint.getArgs();//针对目标对象的类进行日志记录Logger log = Logger.getLogger(target.getClass());log.info(target.getClass() +""+ methodName + "()params=" + Arrays.toString(args));System.out.println("前置通知，运行在目标方法执行之前。");}

方法中参数

JoinPoint：连接点

通过连接点，可以获得目标对象、方法名、参数

前置通知，执行在目标方法执行之前

后置返回通知

/*** * @Title: afterReturningAdvice* @Description: 定义后置返回通知，它执行在目标方法正在执行，并返回结果以后* @param: @param joinpoint	连接点* @param: @param result 目标方法的返回结果* @return: void 返回类型* @throws*/@AfterReturning(value="pointcut()",returning = "result")public void afterReturningAdvice(JoinPoint joinPoint,Object result) {//目标对象Object target = joinPoint.getTarget();//获得目标方法的方法名String methodName = joinPoint.getSignature().getName();//获得方法正在使用的参数Object[] args = joinPoint.getArgs();//针对目标对象的类进行日志记录Logger log = Logger.getLogger(target.getClass());System.out.println("定义后置返回通知，它执行在目标方法正在执行，并返回结果以后。");log.info(target.getClass() +" "+ methodName + "()result=" + ((result==null) ? "" :result.toString()));}

@AfterReturning(value="pointcut()",returning = "result")

value 表示切入点

returning 目标方法的返回对象，要求与参数中的第一个参数名称保持一致

注：后置返回通知，执行在目标方法正常执行，并返回结果之后

后置异常通知

/*** * @Title: afterThrowingAdvice* @Description: 定义后置异常通知，执行在目标方法抛出异常之后！* @param: @param joinPoint* @param: @param ex 参数说明* @return: void 返回类型* @throws*/@AfterThrowing(value="pointcut()",throwing = "ex")public void afterThrowingAdvice(JoinPoint joinPoint,Exception ex) {//目标对象Object target = joinPoint.getTarget();//获得目标方法的方法名String methodName = joinPoint.getSignature().getName();//针对目标对象的类进行日志记录Logger log = Logger.getLogger(target.getClass());System.out.println("定义后置异常通知，执行在目标方法抛出异常之后！");log.error(target.getClass() +" "+ methodName +"" );}

@AfterThrowing(value="pointcut()",throwing = "ex")

value：表示切入点

returning：目标方法的返回对象，要求与参数中的第一个参数名称保持一致

注：后置异常通知，执行在目标方法抛出异常之后

后置通知

/*** * @Title: afterAdvice* @Description: 后置通知，它运行在程序不管是否抛出异常，或者是否正常执行，该通知都会执行* @param: @param joinPoint 连接点* @return: void 返回类型* @throws*/@After("pointcut()")public void afterAdvice(JoinPoint joinPoint) {System.out.println("后置通知，它运行在程序不管是否抛出异常，或者是否正常执行，该通知都会执行");}

注：后置通知，执行在目标方法执行之后（不管是否抛出异常还是成功执行，该通知后都会执行）

环绕通知

/*** * @Title: aroundAdvice* @Description: 环绕通知，唯一一个可以控制目标方法是否执行的通知，* 				也可以修改目标方法的参数、返回，功能很强大* tips：慎用！！！* @param: @param joinPoint* @param: @return 参数说明* @return: Object 返回类型* @throws*/@Around("pointcut()")public Object aroundAdvice(ProceedingJoinPoint joinPoint) {//目标对象Object target = joinPoint.getTarget();//获得方法正在使用的参数Object[] args = joinPoint.getArgs();//修改参数DepartmentBean dept = new DepartmentBean();dept.setId(UUID.randomUUID().toString());dept.setDeptName("啦啦啦");args[0] = dept;try {//控制目标方法是否执行joinPoint.proceed();} catch (Throwable e) {e.printStackTrace();}//修改返回结果return null;	}

注意：环绕通知，唯一一个可以控制目标方法是否执行的通知，也可以修改目标方法的参数、返回，功能很强大！一般不适用！

6、应用场景

1、运行日志

​ 实例：

package com.woniuxy.springaop_anno.ascpets;import java.util.Arrays;
import java.util.UUID;
import org.apache.log4j.Logger;
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.stereotype.Component;
import com.woniuxy.springaop_anno.bean.DepartmentBean;@Component
@Aspect
public class RuntimeLogAspect {/*** * @Title: pointcut* @Description: 定义切入点表达式* @param:  参数说明* @return: void 返回类型* @throws*/@Pointcut("execution(public * com.woniuxy.springaop_anno.*mag.service.impl.*ServiceImpl.*(..))")private void pointcut() {}/*** * @Title: beforeAdvice* @Description: 前置通知，运行在目标方法执行之前* @param: @param joinPoint 参数说明* @return: void 返回类型* @throws*/@Before("pointcut()")public void beforeAdvice(JoinPoint joinPoint) {//目标对象Object target = joinPoint.getTarget();//获得目标方法的方法名String methodName = joinPoint.getSignature().getName();//获得方法正在使用的参数Object[] args = joinPoint.getArgs();//针对目标对象的类进行日志记录Logger log = Logger.getLogger(target.getClass());log.info(target.getClass() +""+ methodName + "()params=" + Arrays.toString(args));System.out.println("前置通知，运行在目标方法执行之前。");}/*** * @Title: afterReturningAdvice* @Description: 定义后置返回通知，它执行在目标方法正在执行，并返回结果以后* @param: @param joinpoint	连接点* @param: @param result 目标方法的返回结果* @return: void 返回类型* @throws*/@AfterReturning(value="pointcut()",returning = "result")public void afterReturningAdvice(JoinPoint joinPoint,Object result) {//目标对象Object target = joinPoint.getTarget();//获得目标方法的方法名String methodName = joinPoint.getSignature().getName();//获得方法正在使用的参数Object[] args = joinPoint.getArgs();//针对目标对象的类进行日志记录Logger log = Logger.getLogger(target.getClass());System.out.println("定义后置返回通知，它执行在目标方法正在执行，并返回结果以后。");log.info(target.getClass() +" "+ methodName + "()result=" + ((result==null) ? "" :result.toString()));}/*** * @Title: afterThrowingAdvice* @Description: 定义后置异常通知，执行在目标方法抛出异常之后！* @param: @param joinPoint* @param: @param ex 参数说明* @return: void 返回类型* @throws*/@AfterThrowing(value="pointcut()",throwing = "ex")public void afterThrowingAdvice(JoinPoint joinPoint,Exception ex) {//目标对象Object target = joinPoint.getTarget();//获得目标方法的方法名String methodName = joinPoint.getSignature().getName();//针对目标对象的类进行日志记录Logger log = Logger.getLogger(target.getClass());System.out.println("定义后置异常通知，执行在目标方法抛出异常之后！");log.error(target.getClass() +" "+ methodName +"" );}/*** * @Title: afterAdvice* @Description: 后置通知，它运行在程序不管是否抛出异常，或者是否正常执行，该通知都会执行* @param: @param joinPoint 连接点* @return: void 返回类型* @throws*/@After("pointcut()")public void afterAdvice(JoinPoint joinPoint) {System.out.println("后置通知，它运行在程序不管是否抛出异常，或者是否正常执行，该通知都会执行");}/*** * @Title: aroundAdvice* @Description: 环绕通知，唯一一个可以控制目标方法是否执行的通知，* 				也可以修改目标方法的参数、返回，功能很强大* tips：慎用！！！* @param: @param joinPoint* @param: @return 参数说明* @return: Object 返回类型* @throws*/@Around("pointcut()")public Object aroundAdvice(ProceedingJoinPoint joinPoint) {//目标对象Object target = joinPoint.getTarget();//获得方法正在使用的参数Object[] args = joinPoint.getArgs();//修改参数DepartmentBean dept = new DepartmentBean();dept.setId(UUID.randomUUID().toString());dept.setDeptName("啦啦啦");args[0] = dept;try {//控制目标方法是否执行joinPoint.proceed();} catch (Throwable e) {e.printStackTrace();}//修改返回结果return null;	}
}

2、操作日志

​ 示例：

package com.woniuxy.springaop_anno.ascpets;import java.util.Arrays;
import java.util.Date;
import javax.annotation.Resource;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import com.woniuxy.springaop_anno.anno.MyLog;
import com.woniuxy.springaop_anno.bean.OptLogBean;
import com.woniuxy.springaop_anno.logmag.service.IOptLogService;@Component
@Aspect
public class OptLogAspect {@Resourceprivate IOptLogService optLogServiceImpl;/*** * @Title: afterReturnAdvice* @Description: 后置返回通知* @param: @param joinPoint* @param: @param ret 参数说明* @return: void 返回类型* @throws*/@AfterReturning(value="@annotation(mylog)",returning = "ret")public void afterReturnAdvice(JoinPoint joinPoint,Object ret,MyLog mylog) {OptLogBean log = new OptLogBean();log.setUserName("系统管理员");log.setOptTime(new Date());log.setMenuName(mylog.menuName());log.setOptType(mylog.optType().getOptType());log.setOptData(Arrays.toString(joinPoint.getArgs()));optLogServiceImpl.save(log);}
}

自定义注解MyLog

package com.woniuxy.springaop_anno.anno;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyLog {/*** * @Title: menuName* @Description: 定义一个菜单名称* @param: @return 参数说明* @return: String 返回类型* @throws*/String menuName() default "";/*** * @Title: optType* @Description: 操作类型	0-新增 1-修改 2-删除* @param: @return 参数说明* @return: byte 返回类型* @throws*/OptEnum optType() default OptEnum.SAVE;
}

使用@MyLog的目标方法，都是属于该切面的切入点

自定义枚举类OptEnum类

package com.woniuxy.springaop_anno.anno;public enum OptEnum {//在枚举中，通过调用有参构造，定义枚举实例SAVE((byte)0),UPDATE((byte)1),DELETE((byte)2);/*** 在枚举中定义一个属性*/private byte optType;/*** 	定义一个有参的枚举构造器* 	在枚举类中，构造器前不能写任何访问修饰符，默认就是private* @param optType*/OptEnum(byte optType) {this.optType = optType;}public byte getOptType() {return this.optType;}
}

枚举中，每一个实例都是单实例

枚举中构造器，不能携带任何访问修饰符，默认就是私有的，但是写上private也会报错

3、事务控制

​ 示例：

package com.woniuxy.springaop_anno.ascpets;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;import com.woniuxy.springaop_anno.util.SessionUtil;/*** * @ClassName: TransactionAspect* @Description: * @author: Feiyu* @Company: 蜗牛学院* @date: 2020-7-2 16:28:41* @version: 1.0*/
@Component
@Aspect
public class TransactionAspect {/*** * @Title: afterReturningAdvice* @Description: * @param: @param ret 参数说明* @return: void 返回类型* @throws* * @within 目标类上使用 @Transactional 中所有的方法都是我们的切入点* @Annotation */@AfterReturning(value="@within(com.woniuxy.springaop_anno.anno.Transactional)",returning = "ret")public void afterReturningAdvice(Object ret) {SessionUtil.commit();}/*** * @Title: afterThrowingAdvice* @Description: * @param: @param joinPoint* @param: @param ex 参数说明* @return: void 返回类型* @throws*/@AfterThrowing(value="@within(com.woniuxy.springaop_anno.anno.Transactional)",throwing = "ex")public void afterThrowingAdvice(JoinPoint joinPoint,Exception ex) {SessionUtil.rollback();}
}

4、安全控制

​ 如：防止SQL注入、敏感词过滤