Day 17: Structural patterns - Proxy

目的

将实际执行的服务遮蔽，取而代之的，建立一个代理人负责对外窗口的身份，以及对内与该服务沟通。

说明

我们可能会依照情况的需求，必须将实际运作服务的物件进行遮蔽，这些情况可能是：

服务需要较长的时间启动，等候期间没有回应。
服务本身接触到机密资料，不能开放给外部任意存取。
服务本身在远端主机上，当需要使用时则在本地端建立代理人，由代理人负责连线。
快取机制，减少服务的运作负担。

为了实现以上的需求，需要建立一个代理人，负责对外窗口的一切，任何需求都会先经过代理人这一关，通过这关後才会与实际服务接触、运作等等。

实践的作法是：

观察服务本身的主要功能能不能抽离出虚拟层，让服务与代理人都继承，方便代理人不论在对外或是对内的使用都能简单化。如果无法抽离，则让代理人继承服务。
建立代理人，除了实作虚拟层之外，本身要储存与服务本体的 reference，方便对内的呼叫。
实作虚拟层定义的方法，这边重点在「需求」本身，依照需求量身打照，只要满足需求的情况下才能呼叫实际服务。

以下范例以需求「服务本身接触到机密资料，不能开放给外部任意存取」为核心制作。

UML 图

Proxy Pattern UML Diagram

使用 Java 实作

使用者物件：User

public class User {
    private String id;
    private String name;
    private String level;

    public User(String id, String name, String level) {
        this.id = id;
        this.name = name;
        this.level = level;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getLevel() {
        return level;
    }
}

定义共同方法的虚拟层：AccessDataLibrary

public interface AccessDataLibrary {
    HashMap<String, User> operatorUsers(String token);

    HashMap<String, User> auditUsers(String toke);

    HashMap<String, User> adminUsers(String token);
}

实际服务的物件：AccessData

public class AccessData implements AccessDataLibrary {
    private HashMap<String, User> adminData = new HashMap<>();
    private HashMap<String, User> auditData = new HashMap<>();
    private HashMap<String, User> operatorData = new HashMap<>();

    public AccessData() throws IOException, ParseException {
        for (int i = 0; i < 3; i++) {
            String id = RandomID.exec(5);
            String name = NameSelector.exec();
            adminData.put(name, new User(id, name, "admin"));
        }

        for (int i = 0; i < 5; i++) {
            String id = RandomID.exec(7);
            String name = NameSelector.exec();
            auditData.put(name, new User(id, name, "audit"));
        }

        for (int i = 0; i < 10; i++) {
            String id = RandomID.exec(10);
            String name = NameSelector.exec();
            operatorData.put(name, new User(id, name, "operator"));
        }
    }

    @Override
    public HashMap<String, User> operatorUsers(String token) {
        return operatorData;
    }

    @Override
    public HashMap<String, User> auditUsers(String token) {
        return auditData;
    }

    @Override
    public HashMap<String, User> adminUsers(String token) {
        return adminData;
    }
}

代理人物件：AccessDataProxy（Proxy 物件）

public class AccessDataProxy implements AccessDataLibrary {
    private AccessData accessData;

    public AccessDataProxy() throws IOException, ParseException {
        this.accessData = new AccessData();
    }

    @Override
    public HashMap<String, User> operatorUsers(String token) {
        if (token.contentEquals("operator") || token.contentEquals("audit") || token.contentEquals("admin")) {
            return accessData.operatorUsers("PASS");
        } else {
            return new HashMap<>();
        }
    }

    @Override
    public HashMap<String, User> auditUsers(String token) {
        if (token.contentEquals("audit") || token.contentEquals("admin")) {
            return accessData.auditUsers("PASS");
        } else {
            return new HashMap<>();
        }
    }

    @Override
    public HashMap<String, User> adminUsers(String token) {
        if (token.contentEquals("admin")) {
            return accessData.adminUsers("PASS");
        } else {
            return new HashMap<>();
        }
    }
}

使用介面：AccessDataApp

public class AccessDataApp {
    private AccessDataLibrary middleware;

    public AccessDataApp(AccessDataLibrary middleware) {
        this.middleware = middleware;
    }

    public void pushLaunchButton(User user, String target) {
        System.out.println("身为 " + user.getLevel() + "，尝试取得 " + target + " 等级的资料");
        HashMap<String, User> targetData = null;

        if (target.contentEquals("operator")) {
            targetData = middleware.operatorUsers(user.getLevel());
        } else if (target.contentEquals("audit")) {
            targetData = middleware.auditUsers(user.getLevel());
        } else if (target.contentEquals("admin")) {
            targetData = middleware.adminUsers(user.getLevel());
        }
        System.err.println("\n---系统显示---");

        if (targetData == null) {
            System.err.println("权限不符合");
        } else {
            System.out.println("人员姓名： " + user.getName() + " ，身份： " + user.getLevel() + " ，顺利取得 " + target + " 等级的资料");
            System.out.println("人员清单:");

            for (User listUser : targetData.values()) {
                System.out.println(listUser.getId() + " " + listUser.getName() + " " + listUser.getLevel());
            }
        }

        System.err.println("---系统关闭---\n");
    }
}

测试，建立不同权限的使用者取得不同等级的资料：AccessDataProxySample

public class AccessDataProxySample {
    public static void main(String[] args) throws IOException, ParseException {
        AccessDataLibrary accessDataProxy = new AccessDataProxy();
        AccessDataApp app = new AccessDataApp(accessDataProxy);

        System.out.println("模拟不同权限的人员，取得资料的情境");
        System.out.println("情境一：Operator");
        User operator = new User(RandomID.exec(5), NameSelector.exec(), "operator");
        app.pushLaunchButton(operator, "admin");
        app.pushLaunchButton(operator, "audit");
        app.pushLaunchButton(operator, "operator");

        System.out.println("情境二：Audit");
        User audit = new User(RandomID.exec(5), NameSelector.exec(), "audit");
        app.pushLaunchButton(audit, "admin");
        app.pushLaunchButton(audit, "audit");
        app.pushLaunchButton(audit, "operator");

        System.out.println("情境三：Admin");
        User admin = new User(RandomID.exec(5), NameSelector.exec(), "admin");
        app.pushLaunchButton(admin, "admin");
        app.pushLaunchButton(admin, "audit");
        app.pushLaunchButton(admin, "operator");
    }
}

Utils：NameSelector、RandomID

public class NameSelector {
    private static Random random = new Random();

    public static String exec() throws IOException, ParseException {
        JSONParser parser = new JSONParser();
        Object obj = parser.parse(new FileReader("./src/utils/boyNameList.json")); // 读取 JSON Array，内容是字串阵列
        JSONArray jsonArray = (JSONArray) obj;

        // 0 - 149
        int option = random.nextInt(149 + 0) + 0;
        return (String) jsonArray.get(option);
    }
}

public class RandomID {
    private static final Random RANDOM = new SecureRandom();
    private static final String ALPHABET = "0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";

    private RandomID() {
        throw new IllegalStateException("Utility class");
    }

    public static String exec(int length) {
        StringBuilder buffer = new StringBuilder(length);

        for (int i = 0; i < length; i++) {
            buffer.append(ALPHABET.charAt(RANDOM.nextInt(ALPHABET.length())));
        }

        return new String(buffer);
    }
}

使用 JavaScript 实作