java Proxy和rtti(反射)实现动态代理工厂.doc

java 反射实现动态代理工厂 Proxy

场景
有个类【大排档】（Stall），它有个方法“提供饭菜”（providedMeals），就是“来吃饭”
有个类【饭馆】（Restaurant），它有个方法“提供饭菜”（providedMeals）

这两个类有个特点，都是提供吃饭的地方，都有相同的方法“提供饭菜”（providedMeals）。那可以定义一个接口【提供吃的地方】（ProvidedEatOfLocal），它有个抽象方法“提供饭菜”（providedMeals）。用这两个类去实现这个接口。

不管是【大排档】还是【饭馆】，在“提供饭菜”（providedMeals）前要做“点餐”（ordering）的工作，之后要做“埋单”（payMoney）的工作。

那我们在实现【大排档】和【饭馆】的“提供饭菜”（providedMeals）方法时，把这“点餐”（ordering）和“埋单”（payMoney）的代码加在一前一后就可以啦。

问题
但这是重复代码，如果“点餐”的流程发生了改变（比如从人工点餐变成了机器点餐），那每个实现类的方法实现里面都需要改源代码。

现在只有两个实现类，如果现在又新出现个【大酒店】（GrandHotel）类，它也有个方法“提供饭菜”（providedMeals），它也实现接口【提供吃的地方】（ProvidedEatOfLocal）。以后有更多的类都来实现这个接口。实现类越多，那“提供饭菜”（providedMeals）方法的前后工作一发生改变，那修改的类就会越多。这在设计上是不合理的。

解决方案
我们可以考虑代理模式。

我们创建一个代理人【吃货经纪人】（FoodGoodsBroker）。

【吃货经纪人】可以代理所有【提供吃的地方】的实现类，我们只要有和【吃货经纪人】打交道，从他这里我们可以得到我们吃饭的地方去吃饭。吃饭前后的统一动作（【点餐】、【埋单】）这个【吃货经纪人】会处理，实际用餐的人可以不关心啦（难道这就是传说中的吃霸王餐，不给钱？）。

所有实现了【提供吃的地方】的实现类都和【吃货经纪人】打交道，把吃饭前后的统一动作（【点餐】、【埋单】）交给【吃货经纪人】会处理。【点餐】和【埋单】的行为如果有变化就统一变化。如果新来个【提供吃的地方】的实现类也想这么处理，那它也和【吃货经纪人】打交道。

如上所述，实际使用者（用餐的人）是不去关心各种饭店的具体各种的。而新来的饭店如果可要照这么做，也只要和【吃货经纪人】打交道，就能做到统一处理。而这些统一处理的地方如果方法改变，那就都改变，不要去修改每个实现类的具体方法。

这样最累的就是【吃货经纪人】。而提供者（实现了【提供吃的地方】的实现类）和使用者是完全脱离的。完全符合软件设计的开闭原则。

是不是很一横一撇一捺，外带四把X！！！

另外一个场景也能说明这个问题
数据库的操作有增、删、改、查
在做这四个操作前都要开打一个数据库连接
做完操作后都要关闭这个连接
如果开连接和关连接的代码发生改变，那很多的地方都要改变
这时可以用代理，统一处理这些工作

1----ProvidedEatOfLocal.java
package com.luo.rtti.proxy3;

// 定义接口 -- 提供吃饭的地方
public interface ProvidedEatOfLocal {

// 抽象方法 -- 提供饭菜
void providedMeals();
}

2----Stall.java
package com.luo.rtti.proxy3;

// 定义实现类 -- 大排档 实现 提供吃饭的地方
public class Stall implements ProvidedEatOfLocal {

// 地方的名字
String local_name = "胖哥大排档";

// 实现方法 -- 提供饭菜
public void providedMeals() {

System.out.println("马路边...塑料凳...烧烤...砂锅粥...诸葛烤鱼...还有很多吃的...小龙虾");
}

}

3-----Restaurant.java
package com.luo.rtti.proxy3;

//定义实现类 -- 饭馆 实现 提供吃饭的地方
public class Restaurant implements ProvidedEatOfLocal {

// 地方的名字
String local_name = "湘粤情饭馆";

// 实现方法 -- 提供饭菜
public void providedMeals() {

System.out.println("空调下...坐雅座...红烧肉...清蒸鱼...茄角之恋...还有很多吃的...排骨汤");
}

}

4----config.properties
Stall=com.luo.rtti.proxy3.Stall
Restaurant=com.luo.rtti.proxy3.Restaurant

5----FoodGoodsBroker.java
package com.luo.rtti.proxy3;

import java.io.FileInputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.Enumeration;
import java.util.Properties;

public class FoodGoodsBroker implements InvocationHandler{

// 实际代理目标
private Object target = null;

// 从配置文件中读取 n 个实现了【吃饭的地方】接口的现实类
// 分别实例化对象后存储在数组中
private static ProvidedEatOfLocal[] pels = null;

// 从配置文件中读取 n 个实现了【吃饭的地方】接口的现实类的类名
// 把所有类名存储在数组中
private static String[] restaurantNames;

// 配置文件地址
private static final String CONFIG_NAME = "src\\com\\luo\\rtti\\proxy3\\config.properties";

// 接口名
private static final String INTERFACE_NAME = "com.luo.rtti.proxy3.ProvidedEatOfLocal";

// 分隔文件名的标志
// 根据反射得到某个类实现的接口名称实际为 [interface 包名.接口名] 我们只需要后面的[包名.接口名] 不需要的[interface ]内容
private static final String SEPARATED_NAME_MARK = " ";

// 用静态块来读取配置文件
// 实例化配置的实现类的对象 放置于数组中
static{

System.out.println("吃货经纪人---开始加载...");

// 用Properties读取配置文件中的配置的实际被代理的类
Properties readConfig = new Properties();

try{
// 读取配置文件
FoodGoodsBroker.readConfig(readConfig);

// 统计被代理的类都是实现了“吃饭的地方”的具体数量
// 实例化数组时设置长度用
int implementCount = 0;
implementCount = FoodGoodsBroker.countSestaurants(readConfig);
System.out.println("配置了 " + implementCount + " 个["+FoodGoodsBroker.INTERFACE_NAME+"]接口的实现类");

// 实例化这些实现类的对象 放置于数组中
FoodGoodsBroker.createExamples(readConfig, implementCount);
System.out.println("吃货经纪人---加载完毕...\n");

}catch(Exception e){

System.out.println("读取配置文件（实例化对象）时出现异常");
e.printStackTrace();
}finally{
// 跟根据业务需要编写这部分的代码
}
}

// 用Properties读取配置文件中的配置的实际被代理的类
private static void readConfig(Properties readConfig) throws Exception{

readConfig.load(new FileInputStream(CONFIG_NAME));
}

// 统计配置的类有多少实现了接口
private static int countSestaurants(Properties readConfig)throws Exception{

// 获取配置文件中所有的key
Enumeration keys = readConfig.propertyNames();

// 统计 配置实现规定接口的实现类的数量
int implementCount = 0;

// 遍历配置文件文件所有的key（类名）
while(keys.hasMoreElements()){

// 得到配置文件的某一项 key(类名) 和 value（包.类名）
String key = (String)keys.nextElement();
String valueClass = readConfig.getProperty(key);

// 得到配置的实现类的类对象
Class c = Class.forName(valueClass);

// 得到类对象实现的所有接口
Type [] is = c.getGenericInterfaces();
// 遍历这些所有的接口名
for(Type t: is){

// 截取正确的接口名
String interName = t.toString();
interName = interName.substring(interName.indexOf(SEPARATED_NAME_MARK) + 1);

// 如果有某个实现的接口名和规定的接口名一样--则统计数量 +1
if(INTERFACE_NAME.equals(interName)){
implementCount++;
break;
}
}
}

return implementCount;
}

// 实例化这些实现类的对象 放置于数组中
private static void createExamples(Properties readConfig, int implementCount)throws Exception{

// 如果统计出来【配置实现规定接口的实现类的数量】数量 < 1 就不要做下面的工作啦
if(implementCount < 1){
return;
}

// 给实现【规定接口的现实类】的对象数组初始化长度
// 给实现【规定接口的现实类】的类名数组初始化长度
pels = new ProvidedEatOfLocal[implementCount];
restaurantNames = new String[implementCount];

// 获取配置文件中所有的key
Enumeration keys = readConfig.propertyNames();

// 给数组填充值时的下标-从 0 开始
int index = 0;

// 遍历配置文件文件所有的key（类名）
while(keys.hasMoreElements()){

// 得到配置文件的某一项 key(类名) 和 value（包.类名）
String key = (String)keys.nextElement();
String valueClass = readConfig.getProperty(key);

// 得到配置的实现类的类对象
Class c = Class.forName(valueClass);

// 得到类对象实现的所有接口
Type [] is = c.getGenericInterfaces();
// 遍历这些所有的接口名
for(Type t: is){

// 截取正确的接口名
String interName = t.toString();
interName = interName.substring(interName.indexOf(SEPARATED_NAME_MARK) + 1);

// 如果有某个实现的接口名和规定的接口名一样
if(INTERFACE_NAME.equals(interName)){

// 把配置的类名放置正确下标的数组中
restaurantNames[index] = key;

// 通过实现类的类对象得到实现类的实例
// 把示例放置正确下标的数组中
Object o = c.newInstance();
pels[index] = (ProvidedEatOfLocal)o;

// 下标 +1
index++;
}
}
}
}

// 私有化构造方法（创建代理类-类对象中有被代理的接口实现类的对象引用）
private FoodGoodsBroker(ProvidedEatOfLocal target){
this.target = target;
}

// 饭前---根据业务需要给设置为静态方法
private void eatFront(){

String name = "暂时不知道名称的地方";

try{

Field f = this.getTarget().getClass().getDeclaredField("local_name");
name = f.get(this.target).toString();

}catch(Exception e){

System.out.println("读取吃饭的地方名称出现异常");
e.printStackTrace();
}finally{

}

System.out.println("来到 [" + name + "]吃东西");
System.out.println("吃饭前干什么呢...开始点餐...");
}

// 饭后---根据业务需要给设置为静态方法
private void eatAfter(){

System.out.println("吃饭后干什么呢...埋单...擦嘴...抬屁股走人...\n");
}

// 通过代理形式得到的实现类对象，调用方法后实现实行的方法体
// 实现 InvocationHandler 接口的实现方法---在代理实例上处理方法调用并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

this.eatFront();

Object result = method.invoke(target, args);

this.eatAfter();

return result;
}

// 实际产生代理---外部通过此方法的调用得到被代理的接口实现类的对象
public static ProvidedEatOfLocal getProvidedEatOfLocal(String restaurantName){

// 得到数组长度
int length = FoodGoodsBroker.restaurantNames.length;

// 遍历 存储了实现正确接口的类名数组
for(int i = 0; i < length; i++){

// 如果外部要得到的实例类名和数组中的某个相同
if(FoodGoodsBroker.restaurantNames[i].equals(restaurantName)){

// 把实现类的实例从数组中得到（放置时的下标就是对应的）
ProvidedEatOfLocal pel = pels[i];

// 创建代理类（类对象中有被代理的接口实现类的对象引用）
FoodGoodsBroker fb = new FoodGoodsBroker(pel);

// 得到一个被代理的类对象实例-而且这个被代理的类对象和代理类对象有联系啦
// 通过这个方法被代理类（从数组中拿出来的 pel）和代理类对象（含被代理类对象的 fb）已经产生了联系
Object o = Proxy.newProxyInstance(pel.getClass().getClassLoader(),
pel.getClass().getInterfaces(),
fb);

// 得到的被代理的类对象实例其实就是它本身实现的接口类型
return (ProvidedEatOfLocal)o;
}
}

return null;
}

// 得到存储了实现正确接口的类名数组
public static String[] getRestaurantNames() {
return restaurantNames;
}

private Object getTarget() {
return target;
}
}

6----Test.java
package com.luo.rtti.proxy3;

public class Test {

public static void main(String[] args) throws Exception {

// 加载代理类的类定义
// 只要用了代理类就会自动加载，本句代码在此场景中无实质意义，可以不写
Class.forName("com.luo.rtti.proxy3.FoodGoodsBroker");

ProvidedEatOfLocal pel = null;

// 拿到所有现实类的类名
String [] names = FoodGoodsBroker.getRestaurantNames();

// 变量所有类名
for(String name: names){

// 根据某个类名得到已经产生代理联系的实现类的对象实例
pel = FoodGoodsBroker.getProvidedEatOfLocal(name);
// 调用对象实例的方法
// 因为和代理类对象已经有了关系，所有会通知到代理类对象，代理类对象会做点自己想做的事情
pel.providedMeals();
}

}

}

暂只配置了com.luo.rtti.proxy3.Stall和com.luo.rtti.proxy3.Restaurant
运行结果

吃货经纪人---开始加载...
配置了 2 个[com.luo.rtti.proxy3.ProvidedEatOfLocal]接口的实现类
吃货经纪人---加载完毕...

来到 [胖哥大排档]吃东西
吃饭前干什么呢...开始点餐...
马路边...塑料凳...烧烤...砂锅粥...诸葛烤鱼...还有很多吃的...小龙虾
吃饭后干什么呢...埋单...擦嘴...抬屁股走人...

来到 [湘粤情饭馆]吃东西
吃饭前干什么呢...开始点餐...
空调下...坐雅座...红烧肉...清蒸鱼...茄角之恋...还有很多吃的...排骨汤
吃饭后干什么呢...埋单...擦嘴...抬屁股走人...

现在新增一个实现类【大酒店】（GrandHotel），也要被代理

7---- GrandHotel.java
package com.luo.rtti.proxy3;

//定义实现类 -- 大酒店 实现 提供吃饭的地方
public class GrandHotel implements ProvidedEatOfLocal {

// 地方的名字
String local_name = "龙华大酒店";

// 实现方法 -- 提供饭菜
public void providedMeals() {

System.out.println("金碧辉煌下...要吃点好点...燕鲍翅...龙虾要吃大的...鹅肝、鱼子酱有木有...最后来点清肠胃的...清炒野菜配小蘑菇汤");
}
}

在配置文件中增加一个配置项
GrandHotel=com.luo.rtti.proxy3.GrandHotel

运行结果
吃货经纪人---开始加载...
配置了 3 个[com.luo.rtti.proxy3.ProvidedEatOfLocal]接口的实现类
吃货经纪人---加载完毕...

来到 [胖哥大排档]吃东西
吃饭前干什么呢...开始点餐...
马路边...塑料凳...烧烤...砂锅粥...诸葛烤鱼...还有很多吃的...小龙虾
吃饭后干什么呢...埋单...擦嘴...抬屁股走人...

来到 [湘粤情饭馆]吃东西
吃饭前干什么呢...开始点餐...
空调下...坐雅座...红烧肉...清蒸鱼...茄角之恋...还有很多吃的...排骨汤
吃饭后干什么呢...埋单...擦嘴...抬屁股走人...

来到 [龙华大酒店]吃东西
吃饭前干什么呢...开始点餐...
金碧辉煌下...要吃点好点...燕鲍翅...龙虾要吃大的...鹅肝、鱼子酱有木有...最后来点清肠胃的...清炒野菜配小蘑菇汤
吃饭后干什么呢...埋单...擦嘴...抬屁股走人...

以后增加再多的需要代理的实现类
只需要做两部
1-增加的类实现正确的接口
2-在配置文件中增加配置文件