欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-03-26 17:49:05
面向切面编程AOP先来看一个问题,如何在不侵入原有Java方法的代码的前提下,扩展增强这个Java方法?可以使用代理模式,代理模式是将一些非业务或者公共的处理部分的代码抽取出来,与业务代码解耦,不侵入原代码从而也能强化类的功能。代理模式分为静态代理和动态代理静态代理静态代理,就是在运行之前,代理类就已经存在代理类继承原有类,重写原有类的方法,在重写的方法中调用原有类的方法(supper.方法),在supper.方法之前或之后加入扩展逻辑新建一个Person类,写一个run方法packag...

本文主要讲了代理模式与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方法进行了扩展

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

新建一个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执行后

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

  1. 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());
    }
}
  1. 在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
  1. 在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 + "!!";
    }
}
  1. 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;
 }
  1. applicationContext.xml文件中对环绕通知进行配置
<!-- 
    环绕通知,可以在方法中对前置、后置、返回后,异常通知进行任意组合使用
    arg-names="pjp",与环绕通知方法的形参是一致的
     -->
<aop:around method="around" pointcut-ref="pt" arg-names="pjp"/>

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

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