概念

为其他类提供一种机制，以控制对这个类的访问

动机

直接访问某一对象有时会带来些问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

结构

组件

• 抽象角色

通过接口或抽象类声明真实角色实现的业务方法。

• 代理角色

实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作

• 真实角色

实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用

分类

静态代理

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类

实现

这里引用《大话设计模式》里面的一个例子说明:追求者找同学送礼物给女神

package proxy;

public class Girl {
 private String name;
 private int age;

 public Girl(String name) {
 this.name = name;
 }

 public String getName() {
 return name;
 }
}

抽象角色

package proxy;

public interface SendGift {
 public void sendFlower();

 public void sendCake();
}

真实角色

package proxy;

public class Persuit implements SendGift {
 private Girl girl;

 public Persuit(Girl girl) {
 this.girl = girl;
 }

 @Override
 public void sendFlower() {
 System.out.println(girl.getName() + "送你花");
 }

 @Override
 public void sendCake() {

 System.out.println(girl.getName() + "送你蛋糕");
 }
}

代理角色

package proxy;

public class Proxy implements SendGift {
 private Persuit persuit;

 public Proxy(Girl girl){
 persuit = new Persuit(girl);

 }

 @Override
 public void sendFlower() {
 persuit.sendFlower();

 }

 @Override
 public void sendCake() {

 persuit.sendCake();
 }
}

动态代理

• 代理对象,不需要实现接口，但需要指定接口的类型
• 代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
• 动态代理也叫做:JDK代理,接口代理

下面我们用动态代理的方式实现上面送礼物的过程

• 首先先创建抽象委托类

package dynamic;
//委托抽象类

public interface SendGift {
 public boolean sendFlower();

 public boolean sendCake();
}

• 然后创建具体委托类

package dynamic;

public class Girl {
 private String name;
 private int age;

 public Girl(String name) {
 this.name = name;
 }

 public String getName() {
 return name;
 }
}

package dynamic;

import static java.lang.Thread.sleep;

//真实委托类
public class Persuit implements SendGift {


 private Girl girl;

 private String name;

 public Persuit(Girl girl, String name) {
 this.girl = girl;
 this.name = name;
 }

 public String getName() {
 return name;
 }

 @Override
 public boolean sendFlower() {
 System.out.println( name +"送"+girl.getName()+"花");
 return true;
 }

 @Override
 public boolean sendCake() {
 System.out.println( name +"送"+girl.getName()+"蛋糕");

 return true;
 }
}

• 创建中间类实现InvocationHandler接口

package dynamic;

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

public class TimingInvocationHandler implements InvocationHandler {

 private Object target;
 // private Persuit target;这里的成员变量类型可以换成object类型

 public TimingInvocationHandler(Object target) {
 super();
 this.target = target;
 }
 public TimingInvocationHandler() {
 super();
 }

 /**
 *
 * @param proxy 通过Proxy.newProxyInstance()生成的代理类对象
 * @param method 表示代理对象被调用的函数
 * @param args 表示代理类对象被调用的函数的参数
 * @return
 * @throws Throwable
 */
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 System.out.println("开始送礼物");
 //target 属性表示真实委托类对象。
 Object obj = method.invoke(target, args);

 System.out.println("送礼物完成");

 return obj;
 }
}

• 客户端通过proxy类新建代理对象

package dynamic;

import java.lang.reflect.Proxy;

public class Client {
 public static void main(String[] args) throws InterruptedException {
 Girl girl = new Girl("芳芳");
 TimingInvocationHandler timingInvocationHandler
 = new TimingInvocationHandler(new Persuit(girl,"小王"));

 SendGift sendGift = (SendGift) Proxy.newProxyInstance(SendGift.class.getClassLoader(), new Class[]{SendGift.class},
 timingInvocationHandler);


 // call method of proxy instance

 sendGift.sendCake();

 sendGift.sendFlower();
 }
}

与装饰模式的区别

相同点

• UML类图基本没区别，都是实现同一个接口，一个类包装另一 个类。
• 两者都是对类的方法进行扩展

代理模式的结构图

装饰者模式的结构图

不同点

• 对对象的作用

装饰者：动态的新增或组合对象的行为，在不改变接口的前提下，动态扩展对象的功能

代理模式：为其他对象提供一种代理以控制对这个对象的访问，在不改变接口的前提下，控制对象的访问

• 如何使用该对象

装饰者：通常将原始对象作为参数传递给Decorator的构造函数。

代理模式：代理类中创建一个真实对象的实例

• 模式的核心

装饰者：强调的是增强自身，在被装饰之后你能够在被增强的类上使用增强后的功能。增强后你还是你，只不过能力更强了而已

代理模式：强调要让别人去做一些本身和你业务没有太多关系的职责（记录日志，设置缓存，远程代理负责网络通信的一些细节），代理模式是为了实现对对象的控制，因为被代理的对象往往难以直接获得或者其内部不想暴露出来