代理模式Proxy深入 动态代理

前一篇文章中介绍了代理模式的概念和一个基本案例代理模式Proxy入门 之帮你追求心仪的姑娘，接下来继续深入学习代理模式一个变种，动态代理。

首先来回顾下代理概念：为一个对象提供代表以控制该对象的访问。上一文案例中代理仅仅是做到代理访问对象的方法，而动态代理是一种根据访问权限决定客户是否可访问对象的代理。

UML图

使用Java API的代理，创建一个动态代理（代理保护）

动态代理是在运行时动态创建的一个代理类，它不会做任何实际的工作，会在生成时需要指定一个InvocationHandler对象，当代理对象方法的调用时，通过在InvocationHandler的invoke方法中做实际操作，换言之，InvocationHandler的工作就是响应代理的任何调用。

java动态代理类位于java.lang.reflect包下，API文档说明

InvocationHandler 是代理实例的调用处理程序 实现的接口。

每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

案例：社交平台会员管理

需求：平台上有多个会员，每个会员需要填写的自己的资料，查看其他人的资料，互相之间可以印象评分，但是不可以给自己评分，也不能修改其他人的资料。

定义会员行为，抽取接口

/** 定义会员接口 */
public interface IPersonBean {

/** 获取姓名 */
String getName();

/** 获取性别 */
String getGender();

/** 获取兴趣爱好 */
String getInterests();

/** 获取会员评分 */
int getRatting();

void setName(String name);

void setGender(String gender);

void setInterests(String interests);

void setRatting(int ratting);
}

实现会员实体类

/** 会员实现类 */
public class PersonBeanImp implements IPersonBean {

private String name;
private String gender;
private String interests;
private int ratting;

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

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

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

@Override
public int getRatting() {
return ratting;
}

@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 setRatting(int ratting) {
this.ratting = ratting;
}

public PersonBeanImp() {
super();
}

public PersonBeanImp(String name, String gender, String interests,
int ratting) {
super();
this.name = name;
this.gender = gender;
this.interests = interests;
this.ratting = ratting;
}

}

会员对自己资料是“拥有者”，我们先实现拥有者对象实例的调用处理程序，首先实现InvocationHandler 接口，复写invoke方法，在invoke方法根据逻辑判断访问权限。此处会员可以访问自己的所有信息，并且可以修改除了评分以外的信息。所以在invoke方法中，当用户尝试修改自己的评分是不允许，则抛出IllegalAccessException，具体见完整代码。

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

/**
* 拥有者对象实例的调用处理程序
*
* InvocationHandler 是代理实例的调用处理程序 实现的接口。
*
* 每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
*/
public class OwnerInvocationHandler implements InvocationHandler {
private IPersonBean personBean;

public OwnerInvocationHandler(IPersonBean personBean) {
super();
this.personBean = personBean;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
try {
if (method.getName().startsWith("get")) {
// 会员可以获得所有 自己的信息
return method.invoke(personBean, args);
} else if (method.getName().equals("setRatting")) {
// 会员没有权限 修改自己的评分
throw new IllegalAccessException();
} else if (method.getName().startsWith("set")) {
// 有权限修改除了评分以外的其他信息
return method.invoke(personBean, args);
}
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return null;
}

}

同理，访问其他会员信息的调用处理程序如下：

/**
* 被拥有者对象实例的调用处理程序
*
* 可以查看其他会员的所有信息，并且可以打分，但是不允许修改其他个人信息
*/
public class NonOnwerInvocationHandler implements InvocationHandler {

private IPersonBean personBean;

public NonOnwerInvocationHandler(IPersonBean personBean) {
super();
this.personBean = personBean;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
try {
if (method.getName().startsWith("get")) {
// 可以查看其他会员的所有信息
return method.invoke(personBean, args);
} else if (method.getName().equals("setRatting")) {
// 可以打分
return method.invoke(personBean, args);
} else if (method.getName().startsWith("set")) {
// 不允许修改其他个人信息
throw new IllegalAccessException();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

}

动态创建代理，实例对象类和 调用处理程序 都定义好了，接下来就定义我们的 动态代理。

public IPersonBean getOwnerProxy(IPersonBean personBean) {
// 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序
return (IPersonBean) Proxy.newProxyInstance(personBean.getClass()
.getClassLoader(), personBean.getClass().getInterfaces(),
new OwnerInvocationHandler(personBean));
}

利用Proxy的静态方法newProxyInstance创建代理

public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于：
Proxy.getProxyClass(loader, interfaces).
getConstructor(new Class[] { InvocationHandler.class }).
newInstance(new Object[] { handler });
Proxy.newProxyInstance 抛出 IllegalArgumentException，原因与 Proxy.getProxyClass 相同。
参数：
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序
返回：
一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口
抛出：
IllegalArgumentException - 如果违反传递到 getProxyClass 的参数上的任何限制
NullPointerException - 如果 interfaces 数组参数或其任何元素为 null，或如果调用处理程序 h 为 null

准备就绪，开始测试吧

import java.lang.reflect.Proxy;

public class DynamicProxyTest {
public static void main(String[] args) {

DynamicProxyTest dynamicProxyTest = new DynamicProxyTest();
dynamicProxyTest.ownerTest();
dynamicProxyTest.nonOwnerTest();
}

private void ownerTest() {
// 初始化一个 李狗蛋 的会员对象
IPersonBean personBean = new PersonBeanImp("李狗蛋", "男", "吃饭睡觉打豆豆", 6);
IPersonBean ownerProxy = getOwnerProxy(personBean);
System.out.println("name:" + ownerProxy.getName());
System.out.println("gender:" + ownerProxy.getGender());
System.out.println("interests:" + ownerProxy.getInterests());
System.out.println("ratting:" + ownerProxy.getRatting());

System.out.println("----------------修改个人信息----------------");
ownerProxy.setName("李白"); // 狗蛋不好听，改个名
ownerProxy.setInterests("吟诗作对，品美酒");

System.out.println("name:" + ownerProxy.getName());
System.out.println("gender:" + ownerProxy.getGender());
System.out.println("interests:" + ownerProxy.getInterests());
System.out.println("ratting:" + ownerProxy.getRatting());

System.out.println("----------------修改评分----------------");
// 嫌弃其他会员给的分太低了，自己给该高点，来个满分10分吧
try {
ownerProxy.setRatting(10);
} catch (Exception e) {
System.err.println("无权限修改自己的评分");
}
System.out.println("ratting:" + ownerProxy.getRatting());
}

private void nonOwnerTest() {
// 初始化一个 李狗蛋 的会员对象
IPersonBean personBean = new PersonBeanImp("李狗蛋", "男", "吃饭睡觉打豆豆", 6);
IPersonBean nonOwnerProxy = getNonOwnerProxy(personBean);
System.out.println("name:" + nonOwnerProxy.getName());
System.out.println("gender:" + nonOwnerProxy.getGender());
System.out.println("interests:" + nonOwnerProxy.getInterests());
System.out.println("ratting:" + nonOwnerProxy.getRatting());

System.out.println("----------------修改评分----------------");
nonOwnerProxy.setRatting(10);
// 我来给狗蛋打个高分，来个满分10分吧
System.out.println("ratting:" + nonOwnerProxy.getRatting());

System.out.println("----------------修改狗蛋的信息----------------");
nonOwnerProxy.setName("李白"); // 狗蛋不好听，改个名
nonOwnerProxy.setInterests("吟诗作对，品美酒");
System.out.println("name:" + nonOwnerProxy.getName());
System.out.println("interests:" + nonOwnerProxy.getInterests());

}

public IPersonBean getOwnerProxy(IPersonBean personBean) {
// 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序
return (IPersonBean) Proxy.newProxyInstance(personBean.getClass()
.getClassLoader(), personBean.getClass().getInterfaces(),
new OwnerInvocationHandler(personBean));
}

public IPersonBean getNonOwnerProxy(IPersonBean personBean) {
// 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序
return (IPersonBean) Proxy.newProxyInstance(personBean.getClass()
.getClassLoader(), personBean.getClass().getInterfaces(),
new NonOnwerInvocationHandler(personBean));
}
}

观察结果：当我们尝试通过动态代理修改自己的评分时，OwnerInvocationHandler 调用处理程序 invoke方法中，通过反射判断该方法不无权限访问，返回异常，尝试给自己修改为10分，由于不满足可最终结果任然是6分。

此时我们动态代理完成了根据权限控制对象访问的目标，好了，完成，哎呀夜已深，好困，小哥去睡了。