Fork me on GitHub

设计模式之代理模式

字数统计: 2.5k字   |   阅读时长≈ 9分

介绍

在代理模式(Proxy Pattern)中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。
在代理模式种，通过创建具有现有对象的对象，以便于向外界提供功能接口。

意图：为其他对象提供一种代理以控制对这个对象的访问

主要解决：直接访问对象带来的问题，在某些情况下（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），用户直接访问对象会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

如何解决：增加中间层

关键代码：实现与被代理类组合。

优点：

  1. 职责清晰。
  2. 高扩展性。
  3. 智能化。

缺点：

  1. 由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。
  2. 实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

目前，代理主要有这样几种方式进行：

  • 静态代理
  • 动态代理
  • cglib代理

静态代理

  • 这种代理方式需要代理对象和目标对象实现一样的接口。
    • 就是在代理对象中生成目标对象，并且在需要代理的方法中，直接调用目标对象的方法就可以了
  • 优点：可以在不修改目标对象的前提下扩展目标对象的功能
  • 缺点：
    • 冗余；由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
    • 不易维护；一旦接口增加方法，目标对象与代理对象都要进行修改

静态代理示例

现有一个订单操作接口，有一个实现类，现在需要扩展实现类的功能，但是不能让用户接触实现类对象，从而使用了代理模式，新建一个实现类，新实现类内部使用原有实现类的方法即可。

UML类图

img

程序实例

操作接口：

1
2
3
4
public interface IOrderService {
    public int saveOrder(String order);

}

实现类：

1
2
3
4
5
6
7
8
public class OrderServiceImpl implements IOrderService{

    @Override
    public int saveOrder(String order) {
        System.out.println("IOrderService接口的实现类的方法");
        return 0;
    }
}

代理类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class OrderServiceStaticProxy implements IOrderService {
    private IOrderService iOrderService;

    public OrderServiceStaticProxy(IOrderService iOrderService) {
        this.iOrderService = iOrderService;
    }

    public void setiOrderService(IOrderService iOrderService) {
        this.iOrderService = iOrderService;
    }

    @Override
    public int saveOrder(String order) {
        System.out.println("静态代理使用方法之前");
        int reuslt = iOrderService.saveOrder(order);
        System.out.println("静态代理使用方法之后");
        return 0;
    }
}

测试过程：

1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
    public static void main(String[] args) {
        IOrderService orderService = new OrderServiceImpl();
        OrderServiceStaticProxy staticProxy = new OrderServiceStaticProxy(orderService);
        staticProxy.saveOrder("order");
    }
}

结果输出：
    静态代理使用方法之前
    IOrderService接口的实现类的方法
    静态代理使用方法之后

从上述示例可以看到，通过静态代理模式，在不改变原有实现类的基础上，通过代理类增强了原有类的方法。

动态代理

首先要知道的是，动态代理无法代理类，只能代理接口。

  • 动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。
  • 动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理

java动态代理机制中有两个重要的类和接口InvocationHandler（接口）和Proxy（类），这一个类Proxy和接口InvocationHandler是我们实现动态代理的核心

InvocationHandler接口

InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口。

每一个proxy代理实例都有一个关联的调用处理程序，每个调用处理程序都实现了InvocationHandler接口；

在代理实例调用方法时，方法调用在编码后，分派到调用处理程序的invoke方法。

官方文档对InvocationHandler接口的描述：

{@code InvocationHandler} is the interface implemented by the invocation handler of a proxy instance.

Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the {@code invoke} method of its invocation handler.

我们能够发现，在动态代理中，代理对象调用方法时，是通过InvocationHandler接口的invoke方法实现。

1
2
3
4
5
6
7
/**
    * proxy:调用这个method的代理实例
    * method:我们所要调用某个对象真实的方法的Method对象
    * args:指代代理对象方法传递的参数
    */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

Proxy类

Proxy类就是用来创建一个代理对象的类，它提供了很多方法，但是我们最常用的是newProxyInstance方法。

1
2
3
4
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException

此方法的作用就是创建一个指定类的代理对象，有三个参数：

  1. ClassLoader loader：一个classloader对象，定义了由哪个类加载器对生成的代理类进行加载
    • 在jvm中，由不同类加载加载同一个类而生成的Class对象并不相同
  2. Class<?>[] interfaces：一个interface对象数组，里面是指定类所实现的接口，同样，代理对象也需要声明实现了这些接口，才能调用接口中声明的方法
  3. InvocationHandler h：一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到这一个InvocationHandler对象上，并最终由其调用。（InvocationHandler对象通过invoke方法调用方法，上面已经提到了）

动态代理示例

定义一个接口类，一个实现类，通过动态代理的方式去使用接口的实现类的方法

  • 首先，定义一个接口People
1
2
3
public interface People {
    public String work();
}
  • 定义一个Teacher类，实现了People对象
1
2
3
4
5
6
7
8
9
public class Teacher implements People{

    @Override
    public String work() {
        System.out.println("老师教书育人...");
        return "教书";
    }

}
  • 定义代理对象的方法处理程序，也就是定义一个InvocationHandler接口的实现类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class WorkHandler implements InvocationHandler{

    //代理类中的真实对象  
    private Object obj;

    public WorkHandler() {
        // TODO Auto-generated constructor stub
    }

    //构造函数，给我们的真实对象赋值
    public WorkHandler(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //在真实的对象执行之前我们可以添加自己的操作
        System.out.println("before invoke。。。");

        //实际调用的Method类的invoke方法执行被代理的方法,返回的invoke对象是方法的返回值
        Object invoke = method.invoke(obj, args);

        //在真实的对象执行之后我们可以添加自己的操作
        System.out.println("after invoke。。。");
        return invoke;
    }
}
  • 开始创建代理类，并使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
//第一种方式
//通过自己实现的调用处理类
public class Test {

    public static void main(String[] args) {
        //要代理的真实对象
        People people = new Teacher();
        //代理对象的调用处理程序，我们将要代理的真实对象传入代理对象的调用处理的构造函数中，最终代理对象的调用处理程序会调用真实对象的方法
        InvocationHandler handler = new WorkHandler(people);
        /**
         * 通过Proxy类的newProxyInstance方法创建代理对象，我们来看下方法中的参数
         * 第一个参数：people.getClass().getClassLoader()，使用people对象的classloader对象来加载我们的代理对象;(因为是同一个类的classloader对象用来加载)
         * 第二个参数：people.getClass().getInterfaces()，这里为代理类提供的接口是真实对象实现的接口，这样代理对象就能像真实对象一样调用接口中的所有方法
         * 第三个参数：handler，我们将代理对象关联到上面的InvocationHandler对象上
         */
        People proxy = (People)Proxy.newProxyInstance(people.getClass().getClassLoader(), people.getClass().getInterfaces(), handler);
        //System.out.println(proxy.toString());
        System.out.println(proxy.work());
    }
}


//第二种方式
//或者直接通过 InvocationHandler接口
public class Test {

    public static void main(String[] args) {
        //要代理的真实对象
        People target = new Teacher();
        //代理对象的调用处理程序，我们将要代理的真实对象传入代理对象的调用处理的构造函数中，最终代理对象的调用处理程序会调用真实对象的方法
        InvocationHandler handler = new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("开启事务");

            // 执行目标对象方法
            Object returnValue = method.invoke(target, args);

            System.out.println("提交事务");
            return null;
        }
    };
    return Proxy.newProxyInstance(classLoader, interfaces, handler);
}
        /**
         * 通过Proxy类的newProxyInstance方法创建代理对象，我们来看下方法中的参数
         * 第一个参数：people.getClass().getClassLoader()，使用people对象的classloader对象来加载我们的代理对象;(因为是同一个类的classloader对象用来加载)
         * 第二个参数：people.getClass().getInterfaces()，这里为代理类提供的接口是真实对象实现的接口，这样代理对象就能像真实对象一样调用接口中的所有方法
         * 第三个参数：handler，我们将代理对象关联到上面的InvocationHandler对象上
         */
        People proxy = (People)Proxy.newProxyInstance(people.getClass().getClassLoader(), people.getClass().getInterfaces(), handler);
        //System.out.println(proxy.toString());
        System.out.println(proxy.work());
    }
}

cglib代理

运行时在内存中 动态生成一个子类对象，从而实现对目标对象功能的扩展。

  • JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。
  • CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

cglib与动态代理的区别：

  • 使用动态代理的对象必须实现一个或多个接口
  • 使用cglib代理的对象则无需实现接口，达到代理类无侵入。

参考

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

xczll：
努力打工中
Golang后台开发、摄影爱好者

很惭愧

只做了一点微小的工作，希望能帮助到你
谢谢大家