所谓动态,也就是说这个东西是可变的,或者说不是一生下来就有的。提到动态就不得不说静态,静态代理,个人觉得是指一个代理在程序中是事先写好的,不能变的,就像上一篇"Java学习笔记——RMI"中的远程代理,其中客户端服务对象就是一个远程服务对象的代理,这个代理可以使得客户在操作时感觉像在操作本地对象一样,远程对象对于客户是透明的。我们可以看出这里的远程代理,是在程序中事先写好的,而本节我们要讨论的远程代理,是由JVM根据反射机制,在程序运行时动态生成的。(以上是本人的理解,如果有不正确的地方,还望读者指正)
上面的类图展示了Java动态代理的中类之间的关系。其中Proxy就是由JVM产生的动态代理类,但是我们不能直接在其中定义我们想要的方法,因为这是由JVM自动生成的,而我们无权去修改,既然我们不能去修改Proxy,那么我们怎么才能让代码为我们服务呢?眼睛往右边看一点点,myInvocationHandler,对!我们可以把我们的代码放在这里。实际上我们每次去找代理为我们办事的时候,代理总会把我们的请求交给myInvocationHandler去处理。
下面以一个例子来详细讲解。本例子摘自《Head First 设计模式》,本人对文章的代码进行少许的修改,并加入了自己的理解说明。
例子中的要求:假设现在有一个在线交友社区系统,每个人可以在线浏览自己和他人的信息,还可以为他人进行打分,但是用户不能为自己进行打分。每个人都会将自己的基本信息展示出来,这些信息可以被自己修改,但是任何他人不得修改自己的个人信息,情理之中嘛。所以这里我们需要创建两个代理,来分别为自己和他人服务,从而可以实现权限控制的目的,使得每个人都可以执行自己权限以内的操作,而对于权限之外的操作是绝对不允许的。
下面开始我们的设计:
首先我们需要定义一个公共接口,这个接口用来被代理和真正的主题所使用,从而可以控制代理和正在的主题具有相同的操作方法。公共接口的代码如下:
1 package pattern.proxy.dynamic;
2
3 /**
4 * 人物对象接口
5 * @author CS_Xiaochao
6 *
7 */
8 public interface Person {
9
10 /*
11 * 声明了一系列的方法
12 */
13 String getName();
14 String getGender();
15 String getInterests();
16 double getHotOrNotRating(); //用于获取用户的投票信息
17
18 void setName(String name);
19 void setGender(String gender);
20 void setInterests(String interests);
21 void setHotOrNotRating(int rating); //设置用户的投票信息
22 }
然后我们来实现它,实现代码如下:
1 package pattern.proxy.dynamic;
2
3 /**
4 * 主题
5 * @author CS_Xiaochao
6 *
7 */
8 public class PersonImpl implements Person{
9
10 private String name;
11 private String gender;
12 private String interests;
13 private int rating;
14 private int ratingCount = 0;
15
16 public PersonImpl() {
17 super();
18 // TODO Auto-generated constructor stub
19 }
20
21 public PersonImpl(String name, String gender, String interests, int rating,
22 int ratingCount) {
23 super();
24 this.name = name;
25 this.gender = gender;
26 this.interests = interests;
27 this.rating = rating;
28 this.ratingCount = ratingCount;
29 }
30
31 /**
32 * 重载了toString方法,方便打印信息
33 */
34 @Override
35 public String toString() {
36
37 return "name:" + name + "\n" +
38 "gender:" + gender + "\n" +
39 "interests:" + interests + "\n" +
40 "rating:" + rating + "\n" +
41 "ratingCount:" + ratingCount;
42 }
43
44 public double getHotOrNotRating() {
45 if (ratingCount == 0) {
46 return 0;
47 } else {
48 return (double)rating / ratingCount;
49 }
50 }
51
52 public void setHotOrNotRating(int rating) {
53 this.rating = rating;
54 ratingCount++;
55 }
56
57 public String getName() {
58 return name;
59 }
60
61 public void setName(String name) {
62 this.name = name;
63 }
64
65 public String getGender() {
66 return gender;
67 }
68
69 public void setGender(String gender) {
70 this.gender = gender;
71 }
72
73 public String getInterests() {
74 return interests;
75 }
76
77 public void setInterests(String interests) {
78 this.interests = interests;
79 }
80
81 public int getRating() {
82 return rating;
83 }
84
85 public void setRating(int rating) {
86 this.rating = rating;
87 }
88
89 public int getRatingCount() {
90 return ratingCount;
91 }
92
93 public void setRatingCount(int ratingCount) {
94 this.ratingCount = ratingCount;
95 }
96 }
真正的干货来啦,让我们开始为Person创建动态代理。之前说过,我们需要两个代理来为我们服务,一个是为自己服务的OwnerInvocationHandler,这个是真正为代理做实际工作的对象,由前面类图中我们可以看到,当用户请求代理为我们服务时,代理实际上是把用户请求转交给了InvocationHandler,对于这里就是OwnerInvocationHandler,它控制用户自己可以修改、查看个人信息,但是绝对不允许为自己投票。具体代码如下:
1 package pattern.proxy.dynamic;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.InvocationTargetException;
5 import java.lang.reflect.Method;
6
7 /**
8 * 服务于自己的做实际工作的代理对象
9 * @author CS_Xiaochao
10 *
11 */
12 public class OwnerInvocationHandler implements InvocationHandler {
13
14 private Person person;
15
16 public OwnerInvocationHandler() {
17 super();
18 // TODO Auto-generated constructor stub
19 }
20
21 public OwnerInvocationHandler(Person person) {
22 super();
23 this.person = person;
24 }
25
26 @Override
27 public Object invoke(Object proxy, Method method, Object[] args)
28 throws IllegalAccessException {
29 Object result = null;
30 try{
31 if(method.getName().equals("setHotOrNotRating")){
32 //对于自己,是不允许为自己投票的
33 throw new IllegalAccessException();
34 }else{
35 //但是自己可以修改、查看自己的个人信息
36 result = method.invoke(person, args);
37 }
38 }catch(InvocationTargetException e){
39 e.printStackTrace();
40 }
41 return result;
42 }
43
44 }
另一个是为他人服务的对象NonOwnerInvocationHandler,它允许别人查看我的个人信息,并为我投票,但是绝对不能修改我的个人信息。具体代码如下:
1 package pattern.proxy.dynamic;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.InvocationTargetException;
5 import java.lang.reflect.Method;
6
7 /**
8 * 为他人服务的真正做实际工作的对象
9 * @author CS_Xiaochao
10 *
11 */
12 public class NonOwnerInvocationHandler implements InvocationHandler {
13
14 private Person person;
15
16 public NonOwnerInvocationHandler() {
17 super();
18 // TODO Auto-generated constructor stub
19 }
20
21 public NonOwnerInvocationHandler(Person person) {
22 super();
23 this.person = person;
24 }
25
26 @Override
27 public Object invoke(Object proxy, Method method, Object[] args)
28 throws IllegalAccessException {
29 Object result = null;
30 try{
31 if(method.getName().equals("setHotOrNotRating")
32 || method.getName().startsWith("get")){
33 //对于他人,可以查看我的个人信息,也可以为我投票
34 result = method.invoke(person, args);
35 }else if(method.getName().startsWith("set")){
36 //但是绝对不可以修改我的个人信息
37 throw new IllegalAccessException();
38 }
39 }catch (InvocationTargetException e) {
40 e.printStackTrace();
41 }
42 return result;
43 }
44 }
最后,我们用一个驱动类来测试我们的代码,具体代码如下:
1 package pattern.proxy.dynamic;
2
3 import java.lang.reflect.Proxy;
4 import java.util.HashMap;
5 import java.util.Map;
6
7 /**
8 * 驱动测试类
9 */
10 public class MatchMakingTestDrive {
11
12 //模拟数据库
13 private static Map<String, Person> tb_person;
14 static{
15 tb_person = new HashMap<String, Person>();
16 tb_person.put("jim", new PersonImpl("jim", "M", "basketball", 0, 0));
17 tb_person.put("lucy", new PersonImpl("lucy", "F", "dance", 0, 0));
18 tb_person.put("lily", new PersonImpl("lily", "F", "sing", 0, 0));
19 tb_person.put("jone", new PersonImpl("jone", "M", "football", 0, 0));
20 tb_person.put("kitty", new PersonImpl("kitty", "F", "play piano", 0, 0));
21 }
22 /**
23 * 模拟根据用户名来从数据库库中查找个人信息
24 * @param name 用户名
25 * @return
26 */
27 private static Person getPersonInfo(String name){
28 Person person = null;
29 if(tb_person != null){
30 person = tb_person.get(name);
31 }
32 return person;
33 }
34
35 /**
36 * 创建一个Person的代理
37 * @param person
38 * @return
39 */
40 private static Person getOwnerProxy(Person person){
41 return (Person) Proxy.newProxyInstance(
42 person.getClass().getClassLoader(),
43 person.getClass().getInterfaces(),
44 new OwnerInvocationHandler(person));
45 }
46
47 /**
48 * 创建一个Person的代理
49 * @param person
50 * @return
51 */
52 private static Person getNonOwenerProxy(Person person){
53 return (Person) Proxy.newProxyInstance(
54 person.getClass().getClassLoader(),
55 person.getClass().getInterfaces(),
56 new NonOwnerInvocationHandler(person));
57 }
58
59 /**
60 * @param args
61 */
62 public static void main(String[] args) {
63 Person jim = getPersonInfo("jim");
64 System.out.println(jim.getName() + "的个人信息:\n" + jim.toString());
65 Person ownerProxy = getOwnerProxy(jim);
66 ownerProxy.setInterests("LOL");
67 try{
68 ownerProxy.setHotOrNotRating(0); //设置自己的投票信息
69 }catch (Exception e) {
70 System.err.println("对不起,不允许设置自己的投票信息!");
71 }
72 System.out.println(jim.getName() + "的个人信息(修改):\n" + jim.toString());
73
74 Person kitty = getPersonInfo("kitty");
75 System.out.println(kitty.getName() + "的个人信息:\n" + kitty.toString());
76 Person nonOwnerProxy = getNonOwenerProxy(kitty);
77 ownerProxy.setInterests("DOTA");
78 try{
79 nonOwnerProxy.setHotOrNotRating(5); //设置别人的投票信息
80 }catch (Exception e) {
81 System.err.println("对不起,不允许设置自己的投票信息!");
82 }
83 System.out.println(kitty.getName() + "的个人信息(修改):\n" + kitty.toString());
84 }
85
86 }
程序的执行结果如下:
1 jim的个人信息:
2 name:jim
3 gender:M
4 interests:basketball
5 rating:0
6 ratingCount:0
7 对不起,不允许设置自己的投票信息!
8 jim的个人信息(修改):
9 name:jim
10 gender:M
11 interests:LOL
12 rating:0
13 ratingCount:0
14 kitty的个人信息:
15 name:kitty
16 gender:F
17 interests:play piano
18 rating:0
19 ratingCount:0
20 kitty的个人信息(修改):
21 name:kitty
22 gender:F
23 interests:play piano
24 rating:5
25 ratingCount:1
接下来,我们来大致分析一下动态代理的执行过程:
当我们执行代码:
Person ownerProxy = getOwnerProxy(jim);
的时候,实际上我们是在执行:
private static Person getOwnerProxy(Person person){
return (Person) Proxy.newProxyInstance(
person.getClass().getClassLoader(),
person.getClass().getInterfaces(),
new OwnerInvocationHandler(person));
}
上面的代码调用了Proxy类的newProxyInstance方法,其源码如下:
1 public static Object newProxyInstance(ClassLoader loader,
2 Class<?>[] interfaces,
3 InvocationHandler h)
4 throws IllegalArgumentException
5 {
6 if (h == null) {
7 throw new NullPointerException();
8 }
9
10 /*
11 * Look up or generate the designated proxy class.
12 */
13 Class cl = getProxyClass(loader, interfaces);
14
15 /*
16 * Invoke its constructor with the designated invocation handler.
17 */
18 try {
19 Constructor cons = cl.getConstructor(constructorParams);
20 return (Object) cons.newInstance(new Object[] { h });
21 } catch (NoSuchMethodException e) {
22 throw new InternalError(e.toString());
23 } catch (IllegalAccessException e) {
24 throw new InternalError(e.toString());
25 } catch (InstantiationException e) {
26 throw new InternalError(e.toString());
27 } catch (InvocationTargetException e) {
28 throw new InternalError(e.toString());
29 }
30 }
其本质上是创建了一个代理类的实例,然后我们可以将其当做被代理类来使用,只是中间加入了一些我们事先定义的权限控制。然后我们通过代理来调用主题的相关方法:
ownerProxy.setInterests("LOL");
我们的目的是希望通过代理来执行我们需要的操作,但是代理会接着调用InvocationHandler的invoke方法,在这里也就是:
public Object invoke(Object proxy, Method method, Object[] args)
throws IllegalAccessException {
Object result = null;
try{
if(method.getName().equals("setHotOrNotRating")){
//对于自己,是不允许为自己投票的
throw new IllegalAccessException();
}else{
//但是自己可以修改、查看自己的个人信息
result = method.invoke(person, args);
}
}catch(InvocationTargetException e){
e.printStackTrace();
}
return result;
}
其中参数中的proxy对应ownerProxy,method对应setInterests,args对应"LOL",这里就是真正的权限控制的地方,invoke中的代码会决定将当前操作拦截,还是转发给真正的主题去处理。这就达到了我们之前所要求的的利用代理来进行权限控制的目的。