SpringAOP

SpringAOP
一、 面向切面编程（AOP）和面向对象编程（OOP）类似，也是一种编程模式
二、 Spring AOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间 的松耦合目的。
三、 AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔 离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。
四、 AOP 采取横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在事务处理、日志管 理、权限控制、异常处理等方面。
五、 目前最流行的 AOP 框架有两个，分别为 Spring AOP 和 AspectJ。
Joinpoint（连接 点） 指那些被拦截到的点，在 Spring 中，可以被动态代理拦截目标类的方法。
Pointcut（切入点） 指要对哪些 Joinpoint 进行拦截，即被拦截的连接点。
Advice（通知） 指拦截到 Joinpoint 之后要做的事情，即对切入点增强的内容。
Target（目标） 指代理的目标对象。
Weaving（植入） 指把增强代码应用到目标上，生成代理对象的过程。
Proxy（代理） 指生成的代理对象。
Aspect（切面） 切入点和通知的结合。
六、 AspectJ开发AOP
AspectJ 是一个基于 Java 语言的 AOP 框架，它扩展了 Java 语言。 Spring 2.0 以后，新增了对 AspectJ 方式的支持，新版本的 Spring 框架，建议使用 AspectJ 方式开发 AOP。
七、 导入 JAR 包(使用 AspectJ 除了需要导入 Spring AOP 的 JAR 包以外，还需要导入与 AspectJ 相关的 JAR 包，具体如 下：)
spring-aspects-5.2.9.RELEASE.jar ：Spring 为 AspectJ 提供的实现，在 Spring 的包中已经提供。
spring-aspects-5.2.9.RELEASE.jar ：Spring 为 AspectJ 提供的实现，在 Spring 的包中已经提供。
八、 通知类型介绍

1. Before:在目标方法被调用之前做增强处理,@Before只需要指定切入点表达式即可
2. AfterReturning:在目标方法正常完成后做增强,@AfterReturning除了指定切入点表达式后，还可以 指定一个返回值形参名returning,代表目标方法的返回值
3. AfterThrowing:主要用来处理程序中未处理的异常,@AfterThrowing除了指定切入点表达式后，还 可以指定一个throwing的返回值形参名,可以通过该形参名来访问目标方法中所抛出的异常对象
4. After:在目标方法完成之后做增强，无论目标方法时候成功完成。@After可以指定一个切入点表达 式
5. Around:环绕通知,在目标方法完成前后做增强处理,环绕通知是最重要的通知类型,像事务,日志等都 是环绕通知,注意编程中核心是一个ProceedingJoinPoint
   九、 基于XML配置
   通过 JoinPoint 参数可以获得目标对象的类名、目标方法名和目标方法参数等。
   需要注意的是，环绕通知必须接收一个类型为 ProceedingJoinPoint 的参数，返回值必须是 Object 类 型，且必须抛出异常。
   异常通知中可以传入 Throwable 类型的参数，用于输出异常信息。
   1、 编写切面类MyAopAspectXml:
   2、 为了演示方便，新建配置applicationContext_aop_xml.xml，并编写：
   3、 编写测试类：
   十、 基于注解配置
   @Aspect 用于定义一个切面。
   @Before 用于定义前置通知
   @Around 用于定义环绕通知
   @AfterReturning 用于定义后置通知
   @AfterThrowing 用于定义抛出通知
   @After 用于定义最终final通知，不管是否异常，该通知都会执行。
   十一、编写切面类MyAopAspectAnnotation：
   package com.gx.aop;
   import org.aspectj.lang.JoinPoint;
   import org.aspectj.lang.ProceedingJoinPoint;
   import org.aspectj.lang.annotation.*;
   import org.springframework.stereotype.Component;
   @Component//向Spring容器中注册MyAopAspectAnnotation
   @Aspect//切面类的注解
   public MyAopAspectAnnotation() {
   System.out.println(“MyAopAspectAnnotation初始化”);
   }
   /**

• 定义切点 用于取代：<aop:pointcut id=“myPointcut” expression=“execution(*
  com.gx.dao….(…))”/>
• 要求：方法必须是private，没有值，名称自定义，没有参数
  /
  @Pointcut("execution ( com.gx.dao….(…))")
  private void myPointcut() {
  }
  //前置通知
  @Before(value = “myPointcut()”)
  private void myBefore(JoinPoint joinpoint) {
  System.out.print(“前置通知，目标：” + joinpoint.getTarget());
  System.out.print(“方法名称: " + joinpoint.getSignature().getName());
  //参数
  System.out.print(” 参数:[");
  Object[] args = joinpoint.getArgs();
  for (Object objArr : args) {
  System.out.print(objArr + “;”);
  }
  System.out.println("]");
  }
  //环绕通知
  @Around(“myPointcut()”)
  private Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws
  Throwable {
  System.out.println(“环绕开始”); // 开始
  Object obj = proceedingJoinPoint.proceed(); // 执行当前目标方法
  System.out.println(“环绕结束”); // 结束
  return obj;
  }
  //后置通知
  @AfterReturning(pointcut = “myPointcut()”, returning = “returnVal”)
  private void myAfterReturning(JoinPoint joinpoint, Object returnVal) {
  System.out.print(“前置通知，目标：” + joinpoint.getTarget());
  System.out.print(“方法名称: " + joinpoint.getSignature().getName());
  //参数
  System.out.print(” 参数:[");
  Object[] args = joinpoint.getArgs();
  for (Object objArr : args) {
  System.out.print(objArr + “;”);
  }
  System.out.print("]");
  System.out.println(" 返回值：" + returnVal);
  }
  //异常通知
  @AfterThrowing(value = “myPointcut()”, throwing = “ex”)
  private void myAfterThrowing(JoinPoint joinpoint, Throwable ex) {
  System.out.println(“异常通知” + “出错了” + ex.toString());
  }
  //final通知
  @After(“myPointcut()”)
  private void myAfter(JoinPoint joinpoint) {
  System.out.println(“最终通知。。”);
  }
  }

十二、为了演示方便，新建配置applicationContext_aop_annotation.xml，并

<?xml version="1.0" encoding="UTF-8"?>

<context:component-scan basepackage=“com.gx.dao,com.gx.service,com.gx.aop”/>

aop:aspectj-autoproxy/

1、 编写测试类：
package com.gx.test;
import com.gx.model.User;
import com.gx.service.IUserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith
(SpringJUnit4ClassRunner.class)//让测试运行于Spring测试环境
@ContextConfiguration
(locations = {“classpath:applicationContext_aop_annotation.xml”})//配置测试时使用的Spring配置文 件，可以多个文件
public class TestAopAnnotation {
@Autowired
private IUserService userService;
@Test
public void test(){
//insert
User user=new User();
user.setName(“Filed Insert”);
user.setAge(34);
userService.insert(user);
User user1=userService.selectUserByName(“Filed Select”);
System.out.println(user1);
}
}