利用Java API创建一个保护代理（Head first 设计模式）

利用Java API创建一个保护代理（Head first 设计模式）

​

​

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

我们需用java的动态代理来实现保护代理，下面以一个简单的需求来引入保护代理

对象村的配对

​ 假设每个城镇都需要约会配对服务，我们负责帮对象村实现约会配对管理系统，有一个好的点子，就是设置“Hot”和"Not"的评鉴，"Hot"代表喜欢，"Not"代表不喜欢。

我们的服务系统首先涉及到一个Person Bean，创建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);

}

创建PersonBean实现类PersonBeanImpl

public class PersonBeanImpl implements PersonBean{
    String name;
    String gender;
    String interests;
    int rating;
    int ratingCount = 0;
    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getGender() {
        return gender;
    }

    @Override
    public String getInterests() {
        return interests;
    }

    @Override
    public int getHotOrNotRating() {
        //计算自己的HotOrNotRating平均值
        if(ratingCount == 0) return 0;
        return rating/ratingCount;
    }

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

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

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

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

​ 这里，系统中的任一用户是可以随意更改别人的数据的，例如我可以随意修改别人的兴趣爱好、性别、HotOrNotRating平均值等等，这显然是不安全的，这可能导致别人约会不到对象。所以我们需要将系统设置为拥有者（自己）才可以修改自己的信息，非拥有者（别人）只能对自己的HotOrNotRating值造成影响，这里就需要用到保护代理——这是一种根据访问权限决定客户可否访问对象的代理

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

步骤一：创建两个InvocationHandler

InvocationHandler实现了代理的行为，java负责创建真正的代理类和对象。我们只需要提供在方法调用时知道做什么的handler

步骤二：写代码创建动态代理

我们需要写一些方法产生代理类（Proxy）实例。等一会儿就会看到

步骤三：测试

步骤一：创建两个InvocationHandler

每当被代理的对象的方法被调用时，就会调用InvocationHandler的实现类里面的invoke()方法。

创建OwnerInvocationHandler（拥有者）

public class OwnerInvocationHandler implements InvocationHandler {
    PersonBean personBean;
    public OwnerInvocationHandler(PersonBean personBean){
        this.personBean = personBean;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("OwnerInvocationHandler->调用了invoke方法");
        try{-u jol,,
            if(method.getName().startsWith("get")){
                return method.invoke(personBean, args);
            }else if(method.getName().equals("setHotOrNotRating")){
                throw new IllegalAccessException();
            }else if(method.getName().startsWith("set")){
                return method.invoke(personBean, args);
            }
        }catch (InvocationTargetException invocationTargetException){
            invocationTargetException.printStackTrace();
        }
        return null;
    }
}

创建NonOwnerInvocationHandler（非拥有者）

public class NonOwnerInvocationHandler implements InvocationHandler {
    PersonBean personBean;
    public NonOwnerInvocationHandler(PersonBean personBean){
        this.personBean = personBean;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("NonOwnerInvocationHandler->调用了invoke方法");
        try{
            if(method.getName().startsWith("get")){
                return method.invoke(personBean, args);
            }else if(method.getName().equals("setHotOrNotRating")){
                return method.invoke(personBean, args);

            }else if(method.getName().startsWith("set")){
                throw new IllegalAccessException();
            }
        }catch (InvocationTargetException invocationTargetException){
            invocationTargetException.printStackTrace();
        }
        return null;
    }
}

步骤二：写代码创建动态代理

编写得到拥有者和非拥有者代理实例的方法

    //得到本人代理实例，因为Proxy和PersonBean实现了相同的接口，所以可以直接返回PersonBean对象
    
  
    public static PersonBean getOwnerProxy(PersonBean person){
        return (PersonBean) Proxy.newProxyInstance(person.getClass().getClassLoader(),
                person.getClass().getInterfaces(),
                new OwnerInvocationHandler(person));
    }

    //得到非本人代理实例，因为Proxy和PersonBean实现了相同的接口，所以可以直接返回PersonBean对象

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

步骤三：测试

创建测试类

public class Test {
    public static void main(String[] args) {
        PersonBean person = new PersonBeanImpl();
        PersonBean ownerProxy = getOwnerProxy(person);
        try {
            ownerProxy.setHotOrNotRating(100);
        } catch (Exception e) {
            System.out.println("自己不能为自己设置分数哦~");
        }
        PersonBean notOwnerProxy = getNotOwnerProxy(person);
        try{
            notOwnerProxy.setGender("男");
        } catch (Exception e){
            System.out.println("不能设置别人的信息~");
        }

    }
}

结果

可以看到我们每次运行时去调用PersonBean实例的方法时，都通过Proxy代理实例将调用传给对应的实现了InvocationHandler接口的实现类。实现了动态代理，在对应的invoke()方法中，也进行了一定的权限控制，控制了对方法的访问，初步实现了保护代理。