Spring 之AOP 面向切面编程

AOP相关术语：

Joinpoint (连接点)：所谓连接点是指那些被拦截到的点，在spring中，这些点指的是方法，因为spring 只支持方法类型的连接点。

Pointcut(切入点)：所谓切入点是指我们要对那些Joinpoint进行拦截的定义。

Adevice(通知/增强)：所谓通知是指拦截到Joinpoint之后要做的事，分为前置通知，后置通知，异常通知，最终通知，环绕通知（切面要完成的功能）

Introduction（引介）：引介是一种特殊的通知在不修改类代码的前提下，Introduction可以在运行期为类动态的添加一些方法或Field

Target（目标对象）：代理的目标对象

Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而AspectJ采用编译器织入和类装载期织入

Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类

Aspect（切面）：是切入点和通知（引介）的结合

通知类型：

• 前置通知：在目标方法执行前执行
• 后置通知：在目标方法执行后执行
• 环绕通知：在目标方法执行前和执行后通知
• 异常抛出通知：在目标方法出现异常时执行
• 最终通知：无论目标方法是否出现异常，最终通知都会执行

引入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:aop="http://www.springframework.org/schema/aop" 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.xsd">

第一种方式我们可以在Xml文件中进行配置：

编写目标对象：

public interface PersonDao {
     public String savePerson();
}

 public class PersonDaoImpl implements PersonDao {
     @Override
     public String savePerson() {
         System.out.println("save person");
         return "return SavePerson";
     }
 }

编写切面类 进行事务管理：

 package com.person;

 import javax.persistence.criteria.Join;

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;

 public class Transaction {
 /**
  * 前置通知
  *  JoinPoint
  *      连接点，代表一个方法，客户端调用哪个方法那个方法就是连接点
  *  通过该参数，可以获取到连接点的一些信息
  * @param joinPoint
  */
     public void beginTransaction(JoinPoint joinPoint){
         //获取目标类
         System.out.println("targetClass   " + joinPoint.getTarget());
         //获取连接点的参数
         System.out.println("args  " + joinPoint.getArgs());
         //获取连接点的名称
         System.out.println("methodName  " + joinPoint.getSignature().getName());
         System.out.println("开启事务");
     }
     /**
      * 后置通知  方法遇到异常  不执行
      * JoinPoint 连接点
      * Object val 接受目标方法的返回值 与配置文件中参函数名一致
      * @param joinPoint
      */
 public void commit(JoinPoint joinPoint,Object val){
     System.out.println(val);
     System.out.println("事务提交");

 }
 /**
  * 最终通知  无论是否发生异常都会执行
  * @param joinPoint
  */
 public void finalyMethod(JoinPoint joinPoint){
     System.out.println("finally method");
 }
 /**
  * 异常通知
  * @param joinPoint    连接点
  * @param ex     接收异常   在文件中配置 参数名一致
  */
 public void throwingMethod(JoinPoint joinPoint,Throwable ex) {
     System.out.println(ex.getMessage());
 }
 /**
  *  环绕通知  在方法前后执行 能够控制方法是否执行
  *      其主要在于，
  *      如果使用around 来作为切入面，连接点的方法就嵌套在around中来执行，
  *      如果around中不获取连接点来执行方法，那么原本的方法不会执行
  *
  *      如果在around执行时同样使用了aftereturning来拦截return就必须，
  *      在around中执行方法的哪一行就行return的获取，再由around再次进行return，
  *      否则afterreturning是拦截不到return的，因为return在around已经断掉了
  *
  *  注意在around 中使用的是 ProceedingJoinPoint
  * @param joinPoint
  * @throws Throwable
  */
 public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable{
     System.out.println("aaaaaa");
     Object val = joinPoint.proceed();//执行目标方法
     System.out.println("bbbbbb");
     return val;
 }
 //public void aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable{
 //    System.out.println("aaaaaa");
 ////    Object val = joinPoint.proceed();//执行目标方法
 //    System.out.println("bbbbbb");
 ////    return val;
 //}
 }

修改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" 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.xsd">
 <bean id="personDao" class="com.person.PersonDaoImpl"></bean>
     <bean id="transaction" class="com.person.Transaction"></bean>
     <aop:config>
         <aop:pointcut
             expression="execution(* com.person.PersonDaoImpl.*(..))"
             id="perform"/>
         <!--  切面 -->
         <aop:aspect ref="transaction">
             <!--    前置通知 -->
               <aop:before method="beginTransaction" pointcut-ref="perform"/>
             <!-- 后置通知
           1、在目标方法执行之后执行 2、能够获取到目标方法的返回值 returning="val"   val:和后置通知方法的接收参数名一样 3、如果目标方法遇到异常，则后置通知将不执行 -->
                 <aop:after-returning method="commit" pointcut-ref="perform" returning="val"/>
             <!-- 最终通知 不管目标方法是否遇到异常，最终通知都将执行 -->
             <aop:after method="finalyMethod" pointcut-ref="perform"/>
             <!--  异常通知 获取目标方法抛出的异常 throwing="ex"和方法中的第二个参数的名称一致 -->
             <aop:after-throwing method="throwingMethod" pointcut-ref="perform" throwing="ex"/>
             <!--   环绕通知  能够控制目标方法的执行 -->
           <!--   <aop:around method="aroundMethod" pointcut-ref="perform"/> -->
         </aop:aspect>
     </aop:config>

 </beans>    

测试代码：

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class PersonTest {

     public static void main(String[] args) {
         ApplicationContext context = new ClassPathXmlApplicationContext("person.xml");
         PersonDao personDao = (PersonDao) context.getBean("personDao");

         personDao.savePerson();
     }
 }

输出结果如下：

targetClass   com.person.PersonDaoImpl@713055ba
args  [Ljava.lang.Object;@20a07db0
methodName  savePerson
开启事务
save person
return SavePerson
事务提交
finally method

第二种方式我们可以利用注解来配置

编写目标对象：

 public class Book {

     public String add() {
         System.out.println("add....books.....");
         return "return Save";
     }
     public void query() {
         System.out.println("query.........");
     }
     public void delete () {
         System.out.println("delete....books.....");

     }
 }

编写切面类：

 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;
 //声明切入面
 @Aspect
 public class BookAspect {

     //在方法上面使用注解完成增强配置
     @Before(value="execution(* cn.aop.Book.*(..))")
     public void before(JoinPoint joinPoint) {
         //获取目标类
         System.out.println("target :" + joinPoint.getTarget());
         //获取连接点的参数
         System.out.println("args  :" + joinPoint.getArgs());
         //获取链接点的名称
         System.out.println("methodName  :" + joinPoint.getSignature().getName());
         System.out.println("before..............");
     }

     @After(value="execution(* cn.aop.Book.*(..))" )
     public void after() {
         System.out.println("after..............");
     }
 //    @AfterReturning(pointcut="pointcut1",returning="val")
 //    @AfterReturning(value="execution(* cn.aop.Book.*(..))",returning="val")
     public void afterReturning(Object val){
         System.out.println(val);
         System.out.println("afterReturning....");

     }
     @AfterThrowing(value = "execution(* cn.aop.Book.*(..))")
     public void afterThrowing(){
         System.out.println("afterThrowing.....");

     }
     @Around(value="execution(* cn.aop.Book.*(..))")
     public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
         System.out.println("aaaaaa");
         Object val = joinPoint.proceed();
         System.out.println("bbbbbb");
         return val;
     }

 }

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" 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.xsd">

     <!-- 开启aop操作 -->
     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
     <!-- 1  配置对象 -->
     <bean id="book" class="cn.aop.Book"></bean>
     <bean id="BookAspect" class="cn.aop.BookAspect"></bean>

 <!--     <aop:config>
         <aop:pointcut expression="execution(* cn.aop.Book.*(..))" id="pointcut1"/>
     </aop:config> -->
 </beans>

编写测试类：

 import javax.sound.midi.Soundbank;
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class TestBook {

     public void testDemo(){
             ApplicationContext context =
                     new ClassPathXmlApplicationContext("book.xml");
             Book book = (Book) context.getBean("book");
             book.add();
             System.out.print("\n");
                 book.delete();
 //        System.out.println("\n");
 //        System.out.println(book.query());
         }
     public static void main(String[] args)  {
         TestBook  test = new TestBook();
                 test.testDemo();
     }
 }

测试结果：

aaaaaa
target :cn.aop.Book@61fc0ce6
args  :[Ljava.lang.Object;@55a19181
methodName  :add
before..............
add....books.....
bbbbbb
after..............

aaaaaa
target :cn.aop.Book@61fc0ce6
args  :[Ljava.lang.Object;@1b6cdb87
methodName  :delete
before..............
delete....books.....
bbbbbb
after..............