Java 实现代理模式以及通过Spring AOP 实现代理模式

阅读量：3905 次

发布时间：2019-05-23

本文共 9835 字，大约阅读时间需要 32 分钟。

文章目录

什么是代理

我们大家都知道微商代理，简单地说就是代替厂家卖商品，厂家“委托”代理为其销售商品。关于微商代理，首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁，也就是说，“委托者”对我们来说是不可见的;其次，微商代理主要以朋友圈的人为目标客户，这就相当于为厂家做了一次对客户群体的“过滤”。我们把微商代理和厂家进一步抽象，前者可抽象为代理类，后者可抽象为目标类(被代理类)。通过使用代理，通常有两个优点，并且能够分别与我们提到的微商代理的两个特点对应起来：

优点一：可以隐藏目标类的实现;

优点二：可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理

参考链接：https://juejin.im/post/5ad3e6b36fb9a028ba1fee6a

代理模式

静态代理

一般将代理类在程序运行之前就存在的代理模式称为静态代理。通常情况下，代理类与目标类都实现了同一接口。

实现步骤

1.目标类：

public class StuServiceImpl implements StuService{
       @Override    public void addStu() {
           System.out.println("add Stu!!!");    }    @Override    public void deleteStu() {
           System.out.println("delete Stu!!!");    }    @Override    public void modifyStu() {
           System.out.println("modify Stu!!!");    }}

2.代理类：

public class AgencyStu implements StuService{
       private  StuService stuService;    //接收目标类实例    public AgencyStu(StuService stuService) {
           this.stuService = stuService;    }    //实现代理    @Override    public void addStu() {
           System.out.println("before add");        stuService.addStu();        System.out.println("end add");    }    @Override    public void deleteStu() {
           System.out.println("before delete");        stuService.deleteStu();        System.out.println("end delete");    }    @Override    public void modifyStu() {
           System.out.println("before modify");        stuService.modifyStu();        System.out.println("end modify");    }}

可以看到上面代理类实现了对目标类的代理，但是由于代理类是在程序运行开始前就存在了，所以当存在不同的代理需求时，还需要再次创建一个新的代理类去实现代理需求，这就造成了代码的冗余，所以就出现了动态代理。

动态代理

基本JDK动态代理

代理类在运行时被创建的代理方式交动态代理。也就是说代理类不是在java代码中定义的，而是在运行过程中在我们java代码的指示下动态生成的。相比于静态代理，它可以实现对代理方法的统一处理，而不用像静态代理一样，挨个去编写重复代码。

实现步骤：

需要创建一个类似于"中介"的类，中介类需要实现InvocationHandler接口，并重写method.invoke方法，然后调用Proxy.newProxyInstance创建代理类，实现动态代理。

例如：

目标类：

public class ShopServiceImpl implements  ShopService{
       @Override    public void addShop() {
           System.out.println("add Shop!!!");    }    @Override    public void deleteShop() {
           System.out.println("delete Shop!!!");    }    @Override    public void queryShop() {
           System.out.println("query Shop!!!");    }}

中介类：

public class Dynamicagency implements InvocationHandler {
       private Object object;    //调用目标类实例    public Dynamicagency(Object object) {
           this.object = object;    }    @Override    //代理类每执行方法时，都会调用此类的invoke方法    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           System.out.println("before");        Object result = method.invoke(object,args);        System.out.println("after");        return result;    }}

动态创建代理类

//生成中介类实例Dynamicagency dynamicagency = new Dynamicagency(new ShopServiceImpl());//生成代理类ShopService shopService = (ShopService) Proxy.newProxyInstance(ShopService.class.getClassLoader(),        new Class[]{
   ShopService.class},dynamicagency);shopService.addShop();

在这里解释一下Proxy.newProxyInstance的参数：

参数1 : loader,类加载器，动态代理类，运行时创建，任何类都需要加载器将其加载到内存。参数2: Class[] interfaces 代理类需要实现的所有接口1. 目标类实例.getClass().getInterfaces(); 注意只能获得自己接口，不能获得父元素接口2. new Class[]{interface.class}参数3：InvocationHandler 处理类，接口，必须进行实现类，一般采取匿名内部类	   提供invoke方法，代理类的每一个方法执行时，都将调用一次invoke。		参数31：Object proxy ： 代理对象		参数32：Method method： 代理对象当前执行的方法的描述对象（反射）		参数33：Object[] args:方法实际参数

因此，代理类执行代理方法，其实就是对实现InvocationHandler 中介类的调用，然后中介类通过反射原理实现对原目标类方法的调用。

Spring 手动代理—JDK动态代理

在这里说一下aop术语：

AOP 术语：

target ：目标类，需要被代理的类，例如： UserService

Joinpoint：连接点，所谓连接点是指那些可能被拦截到的方法。例如所有方法

PonitCut ：切入点，指已经被增强的连接点。例如addUser()

advice：通知/增强，增强代码。例如after，before

Weaving ：织入，是指把增强advice应用到目标对象target来创建的代理对象proxy的过程。

proxy 代理类

Aspect 切面是把pointcut和通知advice的结合。

一个是一个特殊的面

一个切入点和一个通知，组合成一个特殊的面
图示：

实现步骤

目标(委托)类：接口+实现类

public class UserServiceImpl  implements Userservice {
       @Override    public void addUser() {
           System.out.println("add User!!!");    }    @Override    public void deleteUser() {
           System.out.println("delete User!!!");    }    @Override    public void updateUser() {
           System.out.println("update User!!!");    }}

切面类：用于通知

public class MyAspect {
       public void before()    {
           System.out.println("running before");    }    public void after()    {
           System.out.println("running after");    }}

工厂类: 编写工厂生产代理

public class MyBeanfactory {
       public static  Userservice  createUserSerive()    {
           final Userservice userservice = new UserServiceImpl();        final MyAspect myAspect = new MyAspect();        Userservice result = (Userservice) Proxy.newProxyInstance(Userservice.class.getClassLoader()        ,userservice.getClass().getInterfaces(), new InvocationHandler() {
                       @Override                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                           myAspect.before();                        Object object = method.invoke(userservice,args);                        myAspect.after();                        return object;                    }                });        return result;    }}

cglib动态代理

Cglib是一个强大的、高性能的代码生成包，它广泛被许多AOP框架使用，为它们提供方法的拦截。

cglib动态代理的特点是目标类可以不用实现特定的方法，cglib在运行时创建目标类的增强类。

实现步骤

创建目标类（不用实现接口）

public class ShopServiceImpl {
       public void addShop() {
           System.out.println("add Shop!!!");    }    public void deleteShop() {
           System.out.println("delete Shop!!!");    }    public void queryShop() {
           System.out.println("query Shop!!!");    }}

编写拦截器(实现MethodInterceptor)

public class MyMethodIntecetor implements MethodInterceptor {
       private ShopServiceImpl shopService;    public MyMethodIntecetor(ShopServiceImpl shopService) {
           this.shopService = shopService;    }    @Override    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
           System.out.println("before");        //两种方法都可以        //Object result = methodProxy.invokeSuper(proxy,args);        Object result = method.invoke(shopService,args);        System.out.println("after");        return result;    }}

其中MethodInterceptor中intercept方法的参数如下：

proxy 表示的是代理类

method:代理对象当前执行的方法的描述对象（反射）

args:方法实际参数

methodProxy：方法的代理

3. 创建代理类

Enhancer enhancer = new Enhancer();        //添加父类        enhancer.setSuperclass(ShopServiceImpl.class);        //调用回调函数        enhancer.setCallback(new MyMethodIntecetor(new ShopServiceImpl()));        //创建代理对象        ShopServiceImpl shopService = (ShopServiceImpl) enhancer.create();        shopService.addShop();

Spring 手动代理 cglib字节码增强

这种方式主要是通过BeanFactory生产代理对象，与上面不同的就是多个工厂还有含有通知的类。

实现步骤

目标类

public class ShopServiceImpl  {
       public void addShop() {
           System.out.println("add Shop!!!");    }    public void deleteShop() {
           System.out.println("delete Shop!!!");    }    public void queryShop() {
           System.out.println("query Shop!!!");    }}

含有通知的类

public class AdviceClass {
       public void before()    {
           System.out.println("before");    }    public void after()    {
           System.out.println("after");    }}

创建工厂

public class MyBeanFactory {
       public static ShopServiceImpl createShopServiceImpl()    {
           ShopServiceImpl shopService = new ShopServiceImpl();        AdviceClass adviceClass = new AdviceClass();        Enhancer enhancer = new Enhancer();        enhancer.setSuperclass(ShopServiceImpl.class);        enhancer.setCallback(new MethodInterceptor() {
               @Override            //创建匿名内部类            public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                   adviceClass.before();                // 两种写法都可以                //Object result = methodProxy.invokeSuper(object,args);                Object result = method.invoke(shopService,args);                adviceClass.after();                return result;            }        });        ShopServiceImpl proxyShop = (ShopServiceImpl) enhancer.create();        return proxyShop;    }}

Spring 工厂Bean代理 ----半自动化

上面的工厂是我们手动创建的，其实我们可以通过使用Spring中的ProxyFactoryBean代替手动创建工厂。下面是步骤。

实现步骤

目标类

public class UserServiceImpl implements  UserService{
       @Override    public void addUser() {
           System.out.println("addUser!!!");    }    @Override    public void deleteUser() {
           System.out.println("deleteUser!!!");    }    @Override    public void updateUser() {
           System.out.println("updateUser!!!");    }}

切面类

public class MyAspect implements MethodInterceptor {
       @Override    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
           System.out.println("before");        //实现目标类的相应方法        Object object =methodInvocation.proceed();        System.out.println("after");        return object;    }}

接下来是配置xml文件

Spring aop 实现代理

与上面不同的是将配置工厂替换成了aop配置，相比于工厂配置来说更加简便，也可以对拦截条件进行设置。

实现步骤

1.导入aspectjweaver-1.9.4.jar。

2. 引入aop命名空间

在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.目标类：

public class UserServiceImpl implements UserService {
       @Override    public void addUser() {
           System.out.println("addUser!!! springAopProgramm");    }    @Override    public void deleteUser() {
           System.out.println("deleteUser!!! springAopProgramm");    }    @Override    public void updateUser() {
           System.out.println("updateUser!!! springAopProgramm");    }}

4.切面类：

public class MyAspect implements MethodInterceptor {
       @Override    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
           System.out.println("before");        Object object =methodInvocation.proceed();        System.out.println("after");        return object;    }}

5.配置xml