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

秒客网

Spring 之AOP 面向切面编程

相关文章