代理模式 -- 保护代理与Java反射 -- 转

本笔记内容：

1. Java动态代理，反射机制

2. 保护代理

3. 应用保护代理实现的约会系统

----------------------------------------------------------------------------

 

 

走进保护模式

 

我们知道，相亲节目已经在天朝的电视上已经火了多年了，说明了有广大同胞需要这个配对服务，更别说咱们程序猿这个群体了。

现在要实现一个约会服务系统。你希望在这个服务系统中，增加一个评分功能，类似于豆瓣上的评分系统。

浏览一个人资料后，可以给对方进行评分。

你希望这套系统能帮助顾客找到一个理想的对象，这也会让事情更有趣。

 

 

很快，你应该就能想到服务系统需要一个PersonBean的接口，来设置或取得一个人的信息： 

 

//这个接口可以设置和取得人的名字，性别，兴趣，和评分
public interface PersonBean {

    String getName();        // 获取名字
    String getGender();      // 过去性别
    String getInterests();   // 获取兴趣
    int getHotOrNotRating(); // 获取评分值

    void setName(String name);           // 设置姓名
    void setGender(String gender);       // 设置性别
    void setInterests(String interests); // 设置兴趣
    void setHotOrNotRating(int rating);  // 设置评分

}

 

 

然后实现这个接口：

 

public class PersonBeanImpl implements PersonBean {
    String name;
    String gender;
    String interests;
    int rating;
    int ratingCount = 0;

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender;
    }

    public String getInterests() {
        return interests;
    }

    public int getHotOrNotRating() {
        if (ratingCount == 0) return 0;
        return (rating/ratingCount);
    }


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

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setInterests(String interests) {
        this.interests = interests;
    }

    public void setHotOrNotRating(int rating) {
        this.rating += rating;
        ratingCount++;
    }
}

想想如果系统直接使用这个类会有什么问题？

 

如果真的直接用这个类，而不考虑其他题，那么估计很快就会大量用户抱怨：我的兴趣竟然被别人篡改了！！有人竟然给自己评高分！！太不公平了！！

没错，在这个系统中，应该不允许用户篡改别人的数据，如果直接按照上面的类定义，任何客户都可以调用任何方法了。

 

在这个例子中，使用保护代理是最合适不过了。

 

什么是保护代理？是提供某些级别的保护，根据客户的权限和决定客户可否访问哪些特定的方法，所以保护代理可能只提供给客户部分接口。 

 

比如在我们的约会系统中，我们之希望顾客可以设置自己的信息，同时又防止他人更改这些信息。而HotOrNot评分则相反，你不可以更改自己的评分，但是他人可以设置你的评分。

 

 

Java动态代理

 

Java在java.lang.reflect（反射）包中有自己的代理支持，利用这个包你可以在运行时动态地创建一个代理类，实现一个或多个接口，并将方法的调用转发到你所指定的类。因为实际的代理类是在运行时创建的，所以我们称这个Java技术为：动态代理。

 

 

Invocation的工作原理是响应代理的任何调用，可以看成是代理收到方法调用后，请求做实际工作的对象。

我们要用Java的动态代理创建这个约会系统的保护代理。

下面来看怎样用Java动态代理实现保护模式。

 

实现保护代理的约会系统

顾客不可以改变自己的HotOrNot评分，也不可以改变其他顾客的个人信息。为了达到这个目标，必须要创建两个代理：一个用来访问你自己的PersonBean对象，另一个用来访问另一个顾客的PersonBean对象。这样，代理就可以控制在每一种情况下允许哪一种请求了。

 

创建这个代理，就必须使用Java API的动态代理。Java会为我们创建两个代理，而我们只需要提供handler来处理代理转来的方法。

 

步骤一：创建两个InvocationHandler

InvocationHandler实现了代理的行为，Java负责创建真实代理类和对象。我们只需要提供在方法调用发生时知道做什么的handler。我们需要写两个InvocationHandler（调用处理器），其中一个给拥有者使用，另一个给非拥有者使用。究竟什么是InvocationHandler呢？可以这样想：当代理方法被调用时，代理就会把这个调用转发给InvocationHandler，但是这并不是通过调用InvocationHandler的对应方法做到的。

 

给拥有者使用的InvocationHandler:

 

// 拥有者的InvocationHandler

// InvocationHandler在java.lan.reflect包中
import java.lang.reflect.*;


// 所有调用处理器都实现InvocationHandler接口
public class OwnerInvocationHandler implements InvocationHandler {
    PersonBean person;

    // 将person传入构造器，并保持引用
    public OwnerInvocationHandler(PersonBean person) {
        this.person = person;
    }

    // 每次代理的方法被调用，就会导致代理调用此invoke方法
    public Object invoke(Object proxy, Method method, Object[] args)
            throws IllegalAccessException {

        try {
            if (method.getName().startsWith("get")) {
                // 如果方法是一个getter，就允许调用
                return method.invoke(person, args);

            } else if (method.getName().equals("setHotOrNotRating")) {
                // 否则，如果方法是HotOrNotRating(), 因为不能给自己打分，所以就抛出异常，表示不允许
                throw new IllegalAccessException();

            } else if (method.getName().startsWith("set")) {
                // 如果是setter，可以设置自己的信息，所以就给调用
                return method.invoke(person, args);

            }
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null; //其他方法都是未定义的，返回null
    }
}

 

给非拥有者使用的InvocationHandler:

 

 

import java.lang.reflect.*;

public class NonOwnerInvocationHandler implements InvocationHandler {
    PersonBean person;

    public NonOwnerInvocationHandler(PersonBean person) {
        this.person = person;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws IllegalAccessException {

        try {
            if (method.getName().startsWith("get")) {
                // 可以查看其他人的信息
                return method.invoke(person, args);

            } else if (method.getName().equals("setHotOrNotRating")) {
                // 可以给其他人评分
                return method.invoke(person, args);

            } else if (method.getName().startsWith("set")) {
                // 不可以设置别人的信息,所以返回异常
                throw new IllegalAccessException();

            }
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }
}

 

步骤二：创建Proxy类并实例化Proxy对象

现在，只剩下创建动态Proxy类，并实例化Proxy对象了。让我们开始编写一个以PersonBean为参数，并知道如何为PersonBean对象创建拥有者代理的方法，也就是说，我们要创建一个代理，将它的方法调用转发给 OwnerInvocationHandler。

 

下面的方法是调用拥有者的方法

 

   // 此方法需要一个person对象作为参数，然后返回该对象的代理
   // 因为代理和主题有相同的接口，所以我们返回接口PersonBean
PersonBean getOwnerProxy(PersonBean person) {

       // 此代码创建了代理（代码有点丑）
       // 我们利用Proxy类的静态newProxyInstance方法创建代理对象(Java反射机制)
       return (PersonBean) Proxy.newProxyInstance(
            person.getClass().getClassLoader(),  // 将personBean的类载入器当作参数
            person.getClass().getInterfaces(),   // 代理需要实现的接口
               new OwnerInvocationHandler(person)); // 调用非拥有者的处理器
}

 

下面方法获取非拥有者的方法

 

PersonBean getNonOwnerProxy(PersonBean person) {

       return (PersonBean) Proxy.newProxyInstance(
            person.getClass().getClassLoader(),
            person.getClass().getInterfaces(),
               new NonOwnerInvocationHandler(person));
}

 

 

步骤三：测试配对服务系统。利用适当的代理包装任何PersonBean对象。

 

import java.lang.reflect.*;
import java.util.*;

public class MatchMakingTestDrive {
    // 实例变量, 当作是保存顾客的“数据库”
    Hashtable datingDB = new Hashtable();

    public static void main(String[] args) {
        MatchMakingTestDrive test = new MatchMakingTestDrive();
        test.drive();
    }

    public MatchMakingTestDrive() {
        // 在构造器中初始化数据库
        initializeDatabase();
    }

    public void drive() {
        PersonBean joe = getPersonFromDatabase("Joe Javabean");  //从数据库中取出一个人
        PersonBean ownerProxy = getOwnerProxy(joe); // 创建这个人的拥有者代理
        System.out.println("Name is " + ownerProxy.getName()); //  输出这个人的名字
        ownerProxy.setInterests("bowling, Go");  // 使用拥有者代理来设置自己的兴趣
        System.out.println("Interests set from owner proxy");
        try {
            // 尝试用拥有者代理来给自己评分
            ownerProxy.setHotOrNotRating(10);
        } catch (Exception e) {
            // 如果给自己评分会出错
            System.out.println("Can't set rating from owner proxy");
        }
        System.out.println("Rating is " + ownerProxy.getHotOrNotRating());

        // 创建一个非拥有者的代理
        PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
        System.out.println("Name is " + nonOwnerProxy.getName());
        try {
            // 尝试用非拥有者代理来设置兴趣
            nonOwnerProxy.setInterests("bowling, Go");
        } catch (Exception e) {
            // 不可以给别人设置兴趣
            System.out.println("Can't set interests from non owner proxy");
        }
        // 可以给别人评分
        nonOwnerProxy.setHotOrNotRating(3);
        System.out.println("Rating set from non owner proxy");
        System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());
    }

    // 此方法需要一个person对象作为参数，然后返回该对象的代理
    // 因为代理和主题有相同的接口，所以我们返回接口PersonBean
    PersonBean getOwnerProxy(PersonBean person) {
        // 此代码创建了代理（代码有点丑）
        // 我们利用Proxy类的静态newProxyInstance方法创建代理对象(Java反射机制)
        return (PersonBean) Proxy.newProxyInstance(
                person.getClass().getClassLoader(),  // 将personBean的类载入器当作参数
                person.getClass().getInterfaces(),   // 代理需要实现的接口
                new OwnerInvocationHandler(person)); // 调用非拥有者的处理器
    }

    PersonBean getNonOwnerProxy(PersonBean person) {

        return (PersonBean) Proxy.newProxyInstance(
                person.getClass().getClassLoader(),
                person.getClass().getInterfaces(),
                new NonOwnerInvocationHandler(person));
    }

    PersonBean getPersonFromDatabase(String name) {
        return (PersonBean)datingDB.get(name);
    }

    // 初始化“数据库”
    void initializeDatabase() {
        PersonBean joe = new PersonBeanImpl();
        joe.setName("Joe Javabean");
        joe.setInterests("cars, computers, music");
        joe.setHotOrNotRating(7);
        datingDB.put(joe.getName(), joe);

        PersonBean kelly = new PersonBeanImpl();
        kelly.setName("Kelly Klosure");
        kelly.setInterests("ebay, movies, music");
        kelly.setHotOrNotRating(6);
        datingDB.put(kelly.getName(), kelly);
    }
}

 

输出：

 

 

 

小结：

动态代理之所以称为动态代理，是因为运行时才将它的类创建出来。代码开始时，还没有proxy类， 它是根据需要从你传入的接口集创建的。

InvocationHandler不是一个proxy，它只是一个帮助proxy的类，proxy会把调用转发给它处理.Proxy本身是利用静态的Proxy.newProxyInstance()方法在运行时动态创建的。

 

 

代理模式一共记了三篇的笔记：远程代理，虚拟代理，和保护代理。代理模式的还远远不止这些：

 

防火墙代理（Firewall Proxy）：

控制网络资源的访问，保护主题免于“坏客户”的侵害。常用在公司的防火墙系统

 

智能引用代理（Smart Reference Proxy）：

当主题被引用时，进行额外的动作，例如计算一个对象被引用的次数。

 

缓存代理（Caching Proxy）：

为开销大的运算结果提供暂时存储：它也可以允许多个客户共享结果，以减少计算或网络延迟。常用在Web服务器代理，以及内容管理与出版系统。

 

同步代理（Synchronizationi Proxy）: 

在多线程的情况下为主题提供安全的访问。常用在JavaSpaces，为分散式环境内的潜在对象集合提供同步访问控制。

 

复杂隐藏代理（Complexity Hiding Proxy）：

用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理（Facade Proxy），这不难了解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口.

 

写入时复制代理（Copy-On-Write Proxy）：

用来控制对象的复制，方法是延迟对象的复制，知道客户真的需要为止。这是虚拟代理的变体。

 

 

原文：http://blog.csdn.net/shuangde800/article/details/10381495