代理模式与SpringAOP编程的具体实现

本文主要讲了代理模式与SpringAOP编程的具体实现
代理模式是面向切面编程AOP的一种具体实现模式；SpringAOP是一个基于动态代理的AOP框架

代理模式

先来看一个问题，如何在不侵入原有Java方法的代码的前提下，扩展增强这个Java方法？
可以使用代理模式，代理模式是将一些非业务或者公共的处理部分的代码抽取出来，与业务代码解耦，不侵入原代码从而也能强化类的功能。
代理模式分为静态代理和动态代理

静态代理
静态代理，就是在运行之前，代理类就已经存在

1. 代理类继承原有类，重写原有类的方法，在重写的方法中调用原有类的方法（supper.方法），在supper.方法之前或之后加入扩展逻辑

新建一个Person类，写一个run方法

package com.test.proxy;

public class Person {
    public void run(){
        System.out.println("Person类的run方法");
    }
}

新建一个PersonStaticProxy类，继承Person类

package com.test.proxy;

public class PersonStaticProxy extends Person {
    @Override
    public void run() {
        System.out.println("Person类的run方法执行前");
        super.run();
        System.out.println("Person类的run方法执行后");
    }
}

main方法中使用父类Person类型的变量接收PersonStaticProxy的对象（体现了对象的多态），并调用run方法

package com.test.proxy;

public class Test {
    public static void main(String[] args) {
        Person person = new PersonStaticProxy();
        person.run();
    }
}

输出的结果为：

Person类的run方法执行前
Person类的run方法
Person类的run方法执行后

从输出结果可以发现，在不修改Person类的代码前提下，已经对Person类的run方法进行了扩展

2. 代理类与原有类实现相同的接口，原有类对象作为代理类的属性，通过代理类构造方法把原有类对象赋值给代理类的属性，代理类方法调用原有类对象的方法，并且在调用原有类对象的方法前后加入扩展逻辑

新建一个MathematicDao接口，接口中有一个add方法

package com.test.proxy;

public interface MathematicDao {
    public void add(int a, int b);
}

写一个接口的实现类MathematicImpl，重写接口的add方法，并输出一条语句

package com.test.proxy;

public class MathematicImpl implements MathematicDao {
    @Override
    public void add(int a, int b) {
        System.out.println("a加b的值为：" + (a + b));
    }
}

再写一个接口的实现类MathematicProxy ，MathematicProxy 中将实现类MathematicImpl作为属性放在构造方法中传递给MathematicProxy，并在重写接口的add方法中，调用MathematicImpl的add方法，此时就能在MathematicImpl的add方法前后加逻辑，完成对MathematicImpl的add方法的扩展

package com.test.proxy;

public class MathematicProxy implements MathematicDao {
    MathematicImpl mathematic;

    public MathematicProxy( MathematicImpl mathematic){
        this.mathematic = mathematic;
    }

    @Override
    public void add(int a, int b) {
        System.out.println("add方法执行前");
        this.mathematic.add(a, b);
        System.out.println("add方法执行后");
    }
}

main方法中运行，new一个MathematicProxy的对象，并调用其add方法

package com.test.proxy;

public class Test {
    public static void main(String[] args) {
        MathematicDao md = new MathematicProxy(new MathematicImpl());
        md.add(11, 22);
    }
}

输出结果为：

add方法执行前
a加b的值为：33
add方法执行后

静态代理的这两种方式可以实现，不侵入原方法的情况下，来扩展原方法
但是缺点就是，有一个需要扩展的类，就得写一个代理类，那么如果有一百个需要扩展的类，哪怕都是简单的对方法进行扩展，添加一些输出内容，由于是静态代理的方式，也只能是写一百个代理类
而动态代理可以很好的解决这个问题

动态代理
动态代理，就是代理工作是在运行期动态完成，主要有2种，jdk动态代理和cglib动态代理。
要注意，静态代理，动态代理，都是针对方法的不侵入的扩展，代理模式是方法级的操作，是面向方法的

1. jdk动态代理，目标类必须实现接口

首先做一个动态处理器，实现InvocationHandler接口，重写InvocationHandler接口的invoke方法，在invoke方法中写逻辑，即获取要扩展的方法和扩展的逻辑

package com.test.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/*
 * 类DemoProxyHandler实现InvocationHandler接口
 * 实现之后，类DemoProxyHandler是一个动态处理器
 * 作用就是规定对指定对象的方法做什么样的扩展
 */
public class DemoProxyHandler implements InvocationHandler{
    //代理的目标对象，也就是要扩展的方法所属的对象
    private Object obj;
    public DemoProxyHandler(Object obj) {
        this.obj = obj;
    }

    /*
     * method，要扩展的方法，Method通过反射获取对应的方法
     * args，要扩展的方法的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println(method.getName() + "执行前");
        //method.invoke()方法会有Object类型的返回值
        Object res = method.invoke(obj, args);
        System.out.println(method.getName() + "执行后");

        return res;
    }
}

还是使用MathematicDao接口与MathematicImpl实现类

package com.test.proxy;

public interface MathematicDao {
    public void add(int a, int b);
}

package com.test.proxy;

public class MathematicImpl implements MathematicDao {
    @Override
    public void add(int a, int b) {
        System.out.println("a加b的值为：" + (a + b));
    }
}

main方法中调用

package com.test.proxy;

import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        /*
       * 能被jdk动态代理的类得是实现接口的
       * 例如，MathematicsImpl类是MathematicsDao接口的实现类
       * 才能给MathematicsImpl的add方法做扩展
       */
        MathematicDao m = new MathematicImpl();

        //动态处理器
        DemoProxyHandler dp = new DemoProxyHandler(m);

      /*
       * 动态创建代理类
       * 第一个参数loader，指定当前被代理的对象的类加载器
       * 本例中就是new MathematicsImpl()，也就是MathematicsDao m
       * 第二个参数interfaces，被代理的目标对象实现的接口
       * 第三个参数h，指定的动态处理器
       */
        Object obj = Proxy.newProxyInstance(m.getClass().getClassLoader(), m.getClass().getInterfaces(), dp);

        //动态代理类可以用被代理的类的接口类型的变量接收
        MathematicDao mathematicDao = (MathematicDao) obj;

      /*
       * 这里执行的add方法，实际上是执行的DemoProxyHandler中的invoke方法
       */
        mathematicDao.add(1, 3);
    }
}

输出结果为：

add执行前
a加b的值为：4
add执行后

动态代理的好处就是，有多个需要扩展的类（假如要扩展的逻辑是一样的），也只需要有一个动态处理器

2. cglib动态代理
   cglib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类（即继承父类），并在子类中采用方法拦截的技术拦截父类所有方法的调用，顺势织入横切逻辑
   做一个动态代理的处理器，实现MethodInterceptor接口

package com.test.proxy;

/**
 * 动态代理的处理器
 * 规定对被代理的目标对象的方法做什么样的扩展
 */
public class CglibProxyHandler implements MethodInterceptor{

    private Object target;//被代理的目标对象

    /*
     * 根据被代理的目标对象返回其代理对象
     */
    public Object getInstance(Object target) {
        this.target = target;

        //创建加强器enhancer，用来创建代理类
        Enhancer enhancer = new Enhancer();

      /*
       * cglib是通过继承父类的方式实现的动态代理
       * 父类指的就是被代理的目标对象的类
       * 继承此父类的类就是动态代理类
       * enhancer.setSuperclass()中的参数要填父类，即被代理的目标对象的类的class
       */
        enhancer.setSuperclass(target.getClass());

      /*
       * 设置回调，实际上就是设置对被代理目标对象的方法进行怎样的扩展
       * 这个方法的参数需要一个实现了MethodInterceptor的接口的对象
       * MethodInterceptor重写的intercept方法就是定义被代理目标对象的方法进行怎样的扩展
       * 类似jdk动态代理的invoke方法的作用
       * this代表当前这个类的当前的对象，本例中this就是CglibProxyHandler的对象
       */
        enhancer.setCallback(this);

        //创建动态代理类的对象并返回
        return enhancer.create();
    }

    /*
     * intercept方法就是真正对被代理目标对象的方法的扩展
     * 第一个参数arg0，加强器对象enhancer
     * 第二个参数arg1，被代理的目标对象的方法，即要被扩展的方法
     * 第三个参数arg2，是方法的参数
     * 第四个参数arg3，是被代理的目标对象的方法的代理方法，实际操作对象
     */
    @Override
    public Object intercept(Object enhancer, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

        Object res = null;

        System.out.println(method.getName() + "方法执行前");

        try {
            //第一个参数是加强器,第二个参数是方法的参数
            res = methodProxy.invokeSuper(enhancer, args);//相当于调用原方法
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println(method.getName() + "方法执行异常");
        }

        System.out.println(method.getName() + "方法执行后");

        return res;
    }
}

使用Person类作为被代理的目标对象

package com.test.proxy;

public class Person {
    public void run(){
        System.out.println("Person类的run方法");
    }
}

main方法中调用
先创建一个处理器对象，然后由这个对象的getInstance()方法来返回代理对象，getInstance()的参数是被代理的类的对象，getInstance()返回的代理对象就是被代理的类的子类的对象

package com.test.proxy;

import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        CglibProxyHandler cph = new CglibProxyHandler();
      
      /*
       *cph.getInstance(new Person())返回的是代理对象
       *这个代理对象是目标类Person的子类
       * 用父类Person类型的变量接收代理对象，对象的多态
       */
        Person p = (Person) cph.getInstance(new Person());

        p.run();
    }
}

输出的结果为：

Person类的run方法执行前
Person类的run方法
Person类的run方法执行后

JDK与cglib代理对比

1. JDK只能针对实现了接口的类中的方法进行代理

2. Cglib基于继承的方式实现代理，因此无法对static、final类进行代理

3. Cglib无法对private、static方法进行代理

代理模式是面向切面编程AOP的一种具体实现模式
代理模式的作用，就是在不侵入方法的情况下，对方法进行扩展，代理模式是面向方法的操作，但是方法的运行并不是单独存在的，方法是基于对象来运行的，面向方法，也是针对某个对象的方法

AOP是一种编程思想，关注的是方法，是对具体的方法的拓展与分层（不侵入式的扩展），便于开发和维护

SpringAOP的实现

SpringAOP是一个基于动态代理的AOP框架。运行时通过创建目标对象的代理类，对目标对象进行增强，主要使用JDK动态代理和CGLIB代理的方式
实现方式：xml配置或者注解模式
这里用xml配置来实现SpringAOP

需要jar包：
aopalliance-1.0.jar
aspectjweaver-1.7.2.jar
spring-aop-5.2.2.RELEASE.jar
spring-aspects-5.2.2.RELEASE.jar

SpringAOP的具体实现

1. 编写通知类
   切入点有哪些，即在目标对象的方法的哪些位置可以扩展
   一般有四种：方法的执行前、方法的执行后、如果方法有返回值，在方法返回值之后、如果方法有异常，在方法出现异常的时候
   可以从以上4个位置去扩展方法，需要定义4个通知的方法，来完成以上扩展

package com.test.proxy;

/*
 * spring的通知Advice类
 * 这个类的方法就是具体执行对目标的对象的方法进行怎样的扩展
 */
public class MethodAdvice {
    /*
     * JoinPoint连接点，即要进行拓展和分层的方法
     * 这个方法定义的是在方法执行前进行扩展，学名叫前置通知
     */
    public void before(JoinPoint jp) {
        System.out.println("前置通知");
    }

    /*
     * 在方法的执行后进行扩展，学名叫后置通知
     */
    public void after(JoinPoint jp) {
        System.out.println("后置通知");
    }

    /*
     * 在方法返回值之后进行扩展，叫返回后通知
     * 第一个参数jp，连接点
     * 第二个参数obj，连接点(即要扩展的方法)的返回值
     */
    public void afterReturning(JoinPoint jp, Object obj) {
        System.out.println("返回后通知，返回值:" + obj);
    }

    /*
     * 在方法出现异常时进行扩展，叫异常通知
     * 第二个参数e，连接点(即要扩展的方法)的异常
     */
    public void afterThrowing(JoinPoint jp, Exception e) {
        System.out.println("异常通知, 异常:" + e.getMessage());
    }
}

2. 在applicationContext.xml配置文件中添加约束

xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

3. 在applicationContext.xml配置文件中进行AOP配置
   创建通知类的bean对象
   再进行AOP配置，包括切入点表达式，定义切面
   切入点表达式，是定义在哪些包下面的哪些方法需要被扩展
   定义切面就是定义对目标对象的方法进行怎么样的扩展，在定义切面中，不同的标签代表不同的切入点
   注意，xml文件中的配置是与通知类对应的

<!-- 创建通知类的bean对象 -->
  <bean id="methodAdvice" class="com.test.proxy.MethodAdvice"></bean>
  
  <!-- AOP配置 -->
 <aop:config>
   <!-- 
   切入点表达式，定义给哪些类的哪些方法去做AOP处理 
   expression的参数execution( * com.test.proxy.*.*(..))
   第一个*的位置，表示返回值类型，*表示任意返回值(没有返回值也可以)
   第二个*的位置，通配符
   第三个*的位置，或者说(..)之前紧跟着的*，代表的是方法
   *()决定第二个*代表的是类名
   com.test.proxy.*.*，表示这个包下面的所有的类的所有的方法
   (..)，方法的参数，..表示有参数或者无参数都可以
   
   id属性是切入点表达式的唯一标识
   -->
  <aop:pointcut expression="execution( * com.test.proxy.*.*(..))" id="pt"/>
   
   <!-- 定义切面，定义使用哪个bean来做切面 -->
   <aop:aspect ref="methodAdvice">
    <!-- 
    前置通知 <aop:before>
    method，切面类中对应的方法，因为是前置通知，所以method对应通知类中的前置通知方法
    pointcut-ref，给哪些类的哪些方法去做前置通知的扩展，值是切入点表达式aop:pointcut的id
    -->
    <aop:before method="before" pointcut-ref="pt"/>
    
    <!-- 
    后置通知<aop:after>，指定methodAdvice代表的MethodAdvice类中after方法
    作为id为pt的切入点表达式代表的包下的所有的类的方法的后置通知
     -->
    <aop:after method="after" pointcut-ref="pt"/>
    
    <!-- 
    异常通知<aop:after-throwing>，指定methodAdvice代表的MethodAdvice类中afterThrowing方法
    作为id为pt的切入点表达式代表的包下的所有的类的方法的异常通知
    throwing属性的值，是method属性对应方法的Exception类型参数的参数名
     -->
    <aop:after-throwing method="afterThrowing" pointcut-ref="pt" throwing="e"/>
    
    <!-- 
    返回后通知<aop:after-returning>
    returning属性的值，是method属性对应方法的第二个参数的参数名
     -->
    <aop:after-returning method="afterReturning" pointcut-ref="pt" returning="obj"/>
   </aop:aspect>
  </aop:config>
  
  <!-- 当前这个bean是在切入点表达式的覆盖的范围之内 -->
  <bean id="student" class="com.test.proxy.Student"></bean>

xml文件中的切入点表达式，定义了在com.test.proxy包下的所有类的所有方法都会被扩展
即通知类的对象的before方法，会在com.test.proxy包下所有类的所有方法前执行
即通知类的对象的after方法，会在com.test.proxy包下所有类的所有方法后执行
即通知类的对象的afterReturning方法，会在com.test.proxy包下所有类的有返回值的方法执行后执行
即通知类的对象的afterThrowing方法，会在com.test.proxy包下所有类的所有方法出现异常后执行

在com.test.proxy包下，新建一个Student类，需要创建对应的bean

package com.test.proxy;

public class Student {
    public void study() {
        System.out.println("Student类的study方法");
    }

    public String getStr(String s) {
        System.out.println("Student类的带返回值的方法");
        return s + "!!";
    }
}

4. main方法中执行
   main方法中获取student的bean对象，并调用此对象的study和getStr方法
   study方法会被MethodAdvice通知类中的before，after方法所扩展
   getStr方法会被MethodAdvice通知类中的before，after，afterReturning方法所扩展

package com.test.proxy;

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        Student stu= (Student) ctx.getBean("student");

        stu.study();

        stu.getStr("hello");
    }
}

输出结果为：

前置通知
Student类的study方法
后置通知
前置通知
Student类的带返回值的方法
后置通知
返回后通知，返回值:hello!!

环绕通知
如果要对一个连接点（要扩展的方法）的方法，在方法执行前，方法执行后，方法异常时，方法有返回值时进行扩展，并且在一个通知中完成这四个切入点，可以使用环绕通知来完成

1. 环绕通知的具体方法

/*
  * 环绕通知，有一个参数ProceedingJoinPoint pjp
  */
 public Object around(ProceedingJoinPoint pjp) {
  Object result = null;//声明接收返回值的变量
  try {
   System.out.println("方法执行前逻辑");//单独的前置通知
   
   /*
    * 环绕通知的ProceedingJoinPoint pjp参数
    * 有一个无参的proceed()方法，原样执行连接点方法，result = pjp.proceed();
    * 有一个有参的proceed(Object[] arg0)方法，可以改变传入目标方法的参数
    * 给proceed传入新的参数即可，但是，传入的参数类型要与目标方法的参数类型一致
    */
   Object[] newArgs = new Object[] {3,4};
   result = pjp.proceed(newArgs);
   
   System.out.println("方法执行返回后逻辑:" + result);//单独的返回后通知
  } catch (Throwable e) {
   System.out.println("方法执行异常逻辑");//单独的异常通知
   e.printStackTrace();
  }
  System.out.println("方法执行后逻辑");//单独的后置通知
  
  return result;
 }

2. applicationContext.xml文件中对环绕通知进行配置

<!-- 
    环绕通知，可以在方法中对前置、后置、返回后，异常通知进行任意组合使用
    arg-names="pjp"，与环绕通知方法的形参是一致的
     -->
<aop:around method="around" pointcut-ref="pt" arg-names="pjp"/>

如果一个连接点方法，是适用所有的通知(前置、后置、返回后，异常、环绕)
通知执行的先后顺序是前置、环绕、返回后、后置
异常通知不执行，因为环绕通知里面做了异常捕获处理，如果没有异常抛出，异常通知就不执行

3. main方法中进行调用
   还是使用Student类的bean对象，并调用此对象的getStr方法

package com.test.proxy;

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        Student stu= (Student) ctx.getBean("student");

        stu.getStr("环绕通知");
    }
}

输出结果为：

方法执行前逻辑
Student类的带返回值的方法
方法执行返回后逻辑:环绕通知!!
方法执行后逻辑

本文地址：https://blog.csdn.net/sakuraSD/article/details/107898307