设计模式：使用最广泛的代理模式

需求场景

按着惯例，还是以一个应用场景作为代理模式的切入点。现在有一个订单系统，要求是:一旦订单被创建，只有订单的创建人才可以修改订单中的数据，其他人则不能修改。

基本实现思路

按着最直白的思路，就是查询数据库中订单的创建人和当前Session中的登录账号ID是否一致。

class Order {
    private String orderId;
    private String creatorId; // 订单创建者的ID
    private String details; // 订单详情
    // 省略其他属性和getter/setter方法

    public Order(String orderId, String creatorId, String details) {
        this.orderId = orderId;
        this.creatorId = creatorId;
        this.details = details;
    }

    // 其他业务逻辑...
}

系统修改

class OrderService {
    private Map<String, Order> orders = new HashMap<>();

    // 创建订单
    public void createOrder(String orderId, String creatorId, String details) {
        Order order = new Order(orderId, creatorId, details);
        orders.put(orderId, order);
    }

    // 修改订单
    public void modifyOrder(String orderId, String userId, String newDetails) {
        Order order = orders.get(orderId);
        if (order != null) {
            //检查是否拥有权限
            if(order.getCreateId().equals(userId)){
                order.setDetails(newDetails);
            }else{
               System.out.println("权限不足.");
            }
        } else {
            System.out.println("订单不存在.");
        }
    }

    // 其他业务逻辑...
}

该思路的问题

上述代码其实本身是没有问题的，也是Web贫血模式的常见实现思路，即在Service中通过大量的if else进行完成，如果非说问题的话，就是随着对于订单的操作越多Service代码会越发膨胀，例如，需求一开始是只要求改描述，下次又要求更改名称，下下次对于权限又细分等等，Service的modifyOrder就会增加很多的if else和set方法，扩展和维护十分的不优雅。或许下面的代理模式能提供一些能够优雅解决的新思路。

代理模式的定义

代理模式的核心定义是：为其他对象提供一种代理以此来控制对这个对象的访问。代理模式是以对象组合的方式对对象进行保护或者说功能扩展的一种方式。

代理模式结构

Sunject ：目标接口，定义目标对象的具体操作。

Proxy:代理对象，实现与具体的目标对象一样的接口，这样就可以代理具体的目标对象。保存一个指向具体目标对象的引用，可以再需要的时候调用具体的目标对象，调用目标对象时进行控制和保护。

RealSubject：具体的目标对象，真正实现目标接口要求的功能

代码：

// 定义真实主题角色接口
interface Image {
    void display();
}

// 实现真实主题角色
class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk(fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying " + fileName);
    }

    // 模拟从磁盘加载图片资源
    private void loadFromDisk(String fileName) {
        System.out.println("Loading " + fileName + " from disk.");
    }
}

// 定义代理主题角色
interface Proxy extends Image {
    void display();
}

// 实现代理主题角色
class ProxyImage implements Proxy {
    private RealImage realImage;

    public ProxyImage(String fileName) {
        // 延迟加载RealImage对象
        this.realImage = null;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage("image.png");
        }
        realImage.display();
    }
}

public class ProxyPatternDemo {
    public static void main(String[] args) {
        Proxy proxy = new ProxyImage("image.png");
        proxy.display();
    }
}

代理模式实现案例

相当于现在如果有了一个订单对象实例，那么就需要控制外部对它的访问，满足条件的可以访问，不满足条件的就不能访问。

使用代理模式来实现就是需要在Order对象之外再包一层对象，用于操作权限控制。本质上是一种保护代理思路。

首先创建一个订单的操作接口

public interface OrderApi {
    String getId();
    String getName();
    String getDetails();
    String getCreatorId();
    void setId(String id);
    void setDetails(String details);
    void setName(String name);
    void setCreatorId(String creatorId);
}

一个基本的订单实体类作为目标代理对象

class Order implements OrderApi {
    private String id;
    private String name;
    private String details;
    private String creatorId;

    public Order(String id, String name, String details, String creatorId) {
        this.id = id;
        this.name = name;
        this.details = details;
        this.creatorId = creatorId;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getDetails() {
        return details;
    }

    @Override
    public String getCreatorId() {
        return creatorId;
    }

    @Override
    public void setId(String id) {
       
        this.id = id;
    }

    @Override
    public void setName(String name) {
        
        this.name = name;
    }

    @Override
    public void setCreatorId(String creatorId) {
        this.creatorId = creatorId;
    }
    
    @Override
    public void setDetails(String details) {
        this.details= details;
    }
}

实现一个代理对象

class OrderProxy implements OrderApi {
    private Order order;

    public OrderProxy(Order order) {
        this.order = order;
    }

    @Override
    public String getId() {
        return order.getIdO();
    }

    @Override
    public String getName() {
        return order.getNameO();
    }

    @Override
    public String getDetails() {
        return order.getDetailsO();
    }

    @Override
    public String getCreatorId() {
        return order.getCreatorIdO();
    }

    @Override
    public void setId(String id) {
        // 在这里添加权限检查逻辑
        if (isCreator()) {
            order.setId(id);
        } else {
            throw new SecurityException("Only the creator can change the order ID.");
        }
    }

    @Override
    public void setName(String name) {
        // 在这里添加权限检查逻辑
        if (isCreator()) {
            order.setName(name);
        } else {
            throw new SecurityException("Only the creator can change the order name.");
        }
    }

    @Override
    public void setCreatorId(String creatorId) {
        // 创建者ID通常不允许更改
        throw new UnsupportedOperationException("Changing creator ID is not allowed.");
    }

    private boolean isCreator(String userId) {
        // 这里应该添加检查userId是否是订单的创建者
        // 为了示例简单，这里假设userId总是传入正确的，返回true
        return true;
    }
}

代理模式的理解

特点与分类

代理模式的本质是控制对象的访问。通过代理目标对象，把代理对象插入到客户和目标对象之间，从而为客户和目标对象引入一定的间接性。正是这个间接性，给了代理对象很多的活动空间。代理对象可以在调用具体的目标对象前后，附加很多操作，从而实现新的功能或是扩展目标对象的功能。更狠的是，代理对象还可以不去创建和调用目标对象，也就是说，目标对象被完全代理掉了，或是被替换掉了。
从实现上看，代理模式主要是使用对象的组合和委托，尤其是在静态代理的实现里面，会看得更清楚。但是也可以采用对象继承的方式来实现代理。这种实现方式在某些情况下，会比使用组合来的简单。还是以上面权限的例子，以继承的方式实现，首先剔除掉OrderApi

public class Order {
  //仅仅去除OrderApi的实现，其他的代码没有任何变化，就不再赘述了
}

代理对象：

public class OrderProxy extends Order {
    public OrderProxy(String productName, int orderNum, String orderUser) {
        super(productName, orderNum, orderUser);
    }

    public void setProductName(String productName, String user) {
        // 控制访问权限，只有创建订单的人员才能够修改
        if (user == null || user.equals(this.getOrderUser())) {
            super.setProductName(productName, user);
        } else {
            System.out.println("对不起, " + user + "，您无权修改订单中的产品名称。");
        }
    }

    public void setOrderNum(int orderNum, String user) {
        // 控制访问权限，只有创建订单的人员才能够修改
        if (user == null || user.equals(this.getOrderUser())) {
            super.setOrderNum(orderNum, user);
        } else {
            System.out.println("对不起, " + user + "，您无权修改订单中的订购数量。");
        }
    }

    public void setOrderUser(String orderUser, String user) {
        // 控制访问权限，只有创建订单的人员才能够修改
        if (user == null || user.equals(this.getOrderUser())) {
            super.setOrderUser(orderUser, user);
        } else {
            System.out.println("对不起, " + user + "，您无权修改订单中的订购人。");
        }
    }

}

不同的代理类型，这种附加的间接性有不同的用途，也就具有不同的特点。

远程代理:隐藏了一个对象存在于不同的地址空间的事实，也即是客户通过远程代理去访问一个对象，根本就不关心这个对象在哪里，也不关心如何通过网络去访问到这个对象。从客户的角度来讲，它只是在使用代理对象而已。
虚代理:可以根据需要来创建“大”对象，只有到必须创建对象的时候，虚代理才会创建对象，从而大大加快程序运行速度，并节省资源。通过虚代理可以对系统进行优化。
保护代理:可以在访问一个对象的前后，执行很多附加的操作，除了进行权限控制之外，还可以进行很多跟业务相关的处理，而不需要修改被代理的对象。也就是说，可以通过代理来给目标对象增加功能。
智能指引:和保护代理类似，也是允许在访问一个对象的前后，执行很多附加的操作，这样一来就可以做很多额外的事情，比如，引用计数等。

在这些代理类型中，最常见的是保护代理和远程代理。上述的例子就是一个典型的保护代理的实现，即具体订单的操作是不变的，如果需要对订单的操作进行特殊处理，一切变动皆集中在代理对象中，代理对象对于订单对象起到了保护隔离的作用，同时代码层面上也承载了“频繁变化”的需求内容，将“变化”隔离出来，对于后续的需求扩展也是十分有效。

建议在如下情况中选用代理模式。

需要为一个对象在不同的地址空间提供局部代表的时候，可以使用远程代理。
需要按照需要创建开销很大的对象的时候，可以使用虚代理。
需要控制对原始对象的访问的时候，可以使用保护代理。
需要在访问对象执行一些附加操作的时候，可以使用智能指引代理。

具体目标和代理间的关系

Java中代理模式的应用

Java 对代理模式提供了内建的支持，在java.lang,refect 包下面，提供了一个 Proxy的类和一个InvocationHandler 的接口。
通常把前面自己实现的代理模式称为 Java 的静态代理。这种实现方式有一个较大的缺点，就是如果Subject接口发生变化，那么代理类和具体的目标实现都要变化，不是很灵活。而使用Java内建的对代理模式支持的功能来实现则没有这个问题。
通常把使用 Java 内建的对代理模式支持的功能来实现的代理称为Java的动态代理，动态代理跟静态代理相比，明显的变化是:静态代理实现的时候，在Subject接口上定义很多的方法，代理类里面自然也要实现很多方法:而动态代理实现的时候，虽然Subicct接口上定义了很多方法，但是动态代理类始终只有一个invoke 方法。这样，当Subject接口发生变化的时候，动态代理的接口就不需要跟着变化了。
Java的动态代理目前只能代理接口，基本的实现是依靠Java的反射机制和动态生成class的技术，来动态生成被代理的接口的实现对象。具体的内部实现细节这里不去讨论。如果要实现类的代理，可以使用cglib(一个开源的Code Generation Library)。

还是来看看示例，那就修改上面保护代理的示例，看看如何使用Java的动态代理来实现同样的功能。
(1)订单接口的定义是完全一样的，就不再赘述了。
(2)订单对象的实现，只是添加了一个 toString,，以方便测试输出，这里也不去示例了。在前面的示例中，toString已实现在代理类里面了。
(3)直接看看代理类的实现，大致有如下变化。

要实现InvocationHandler接口。
需要提供一个方法来实现:把具体的目标对象和动态代理绑定起来，并在绑定好过后，返回被代理的目标对象的接口，以利于客户端的操作。
需要实现 invoke 方法，在这个方法里面，具体判断当前是在调用什么方法，需要如何处理。

import java.lang.reflect.*;

/**
 * 使用Java中的动态代理
 */
public class DynamicProxy implements InvocationHandler {
    // 被代理的对象
    private OrderApi order;

    /**
     * 获取绑定好代理和具体目标对象后的目标对象的接口
     * @param order 具体的订单对象，相当于具体目标对象
     * @return 绑定好代理和具体目标对象后的目标对象的接口
     */
    public OrderApi getProxyInterface(Order order) {
        // 设置被代理的对象，方便invoke里面的操作
        this.order = order;

        // 把真正的订单对象和动态代理关联起来
        OrderApi orderApi = (OrderApi) Proxy.newProxyInstance(
            order.getClass().getClassLoader(),
            order.getClass().getInterfaces(),
            this);

        return orderApi;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 如果是调用setter方法就需要检查权限
        if (method.getName().startsWith("set")) {
            // 假设Order类有一个getOrderUser()方法来获取订单创建者的用户ID
            // 并且order.getOrderUser().equals(args[0])来检查是否是创建者
            if (order.getOrderUser() != null && order.getOrderUser().equals(args[0])) {
                // 可以操作
                return method.invoke(order, args);
            } else {
                // 如果不是创建者，不能修改
                System.out.println("对不起，" + args[0] + "，您无权修改本订单中的数据");
            }
        } else {
            // 不是调用的setter方法就继续运行
            return method.invoke(order, args);
        }
        return null;
    }
}

使用时则是：

public class Client {
    public static void main(String[] args) {
        // 张三先登录系统创建了一个订单
        Order order = new Order("XXX", 100, "张三");
        // 创建一个动态代理
        DynamicProxy dynamicProxy = new DynamicProxy();
        // 然后把订单和动态代理关联起来
        OrderApi orderApi = dynamicProxy.getProxyInterface(order);

        // 以下就需要使用被代理过的接口来操作了
        // 李四想要来修改，那就会报错
        orderApi.setOrderNum(123, "李四");
        // 输出order
        System.out.println("李四修改后订单记录没有变化：" + orderApi);

        // 张三修改就不会有问题
        orderApi.setOrderNum(123, "张三");
        // 再次输出order
        System.out.println("张三修改后，订单记录：" + orderApi);
    }
}

代理在Java中的使用十分常见，例如Spring中的AOP，其本质就是代理模式。