JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。利用这种机制，可以做很多天马行空的事情，现在简单看看如何利用它进行插件化的编程。
任何不以结婚为目的的谈恋爱都是耍流氓，同样，在具体介绍如何实现这个插件化编程之前，我们来看看这个东西适用于什么场景。
假设我现在有一个持续不断的数据流(data flow)从上游下来，然后我多个服务(server)都需要实时处理这个数据流。然后突然有一天，你老大拍脑子说这个数据流还可以这样子用，然后噼里啪啦和你说了一堆，意思就是叫你在原来的系统上多添加一个服务，你一脸懵逼说这个东西咋不早说一起开发了，但你无从违抗，然后只好去构想怎么去添加？
你可能会比较希望你新添加的服务不用修改或者很少修改原有的代码，你希望你新编写的server D可以像一个插件一样插入到一个服务簇里面，这样做到最小程度的修改原来的代码，如下图所示：
利用java的反射机制，我们可以将当前需要运行的server配置到配置文件里面，主程序从配置文件获取配置信息并加载相应的类，这样以后实现新的server的时候，我只需要编写新的server类，并将类名写到配置文件里面去，就可以实现新server的插入了，完全不用改动原来的代码。
现在我们来看一看，如何实现这么一个程序，看看这个程序在添加新功能的时候是如何一行原来的代码都不改动的。
首先抽象出server的共有接口IServer。
// src/servers/IServer.java
import bean.DataPoint;
public interface IServer {
public void process(DataPoint point);
}
之后所有的Server实现该接口
// src/servers/ServerA.java
import bean.DataPoint;
public class ServerA implements IServer{
public void process(DataPoint point){
System.out.println("ServerA is processing!");
}
}
// src/servers/ServerB.java
import bean.DataPoint;
public class ServerB implements IServer{
public void process(DataPoint point){
System.out.println("ServerB is processing!");
}
}
接着是配置文件，配置文件也很简单
# business servers
business.servers=servers.ServerA, servers.ServerB
最后是主类，主类演示如何从配置文件读取配置，如何利用反射机制加载相应的类，并处理数据。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import bean.DataPoint;
import servers.IServer;
import util.ConfigUtils;
public class Main{
private static Object newInstance(String classname){
try {
Class clazz = Class.forName(classname);
Object obj = clazz.newInstance();
return obj;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
public static void main(String[] args){
// 读配置
final String configPath = "src/config/config.properties";
Properties properties = ConfigUtils.readProperties(configPath);
String p = properties.getProperty("business.servers");
String []tmp = p.split(",");
List svrlist = new ArrayList();
for(String t: tmp){
svrlist.add(t.trim());
}
// 加载servers
ArrayList servers = new ArrayList();
Iterator iter = svrlist.iterator();
while(iter.hasNext()){
String str = iter.next();
IServer server = (IServer) newInstance(str);
if(server != null)
servers.add(server);
}
DataPoint point = new DataPoint();
point.setName("point");
point.setValue(1);
// servers处理
Iterator iter2 = servers.iterator();
while(iter2.hasNext()){
IServer server = iter2.next();
server.process(point);
}
}
}
到此，这个程序已经基本实现，为减少篇幅一些与文章关系不大的代码就没有放出来了。
可以看到在Main.java的newInstance函数里面，使用了反射函数Class.forName进行了类的装载，而参数则是配置文件中配置的类名。如此，当有突然的任务需求需要实现一个ServerC的时候，你只需要继承IServer接口，实现ServerC的业务逻辑，并将ServerC的类配置到配置文件中。如：
# business servers
business.servers=servers.ServerA, servers.ServerB, servers.ServerC
// src/servers/ServerC.java
import bean.DataPoint;
public class ServerC implements IServer{
public void process(DataPoint point){
System.out.println("ServerC is processing!");
}
}
就可以实现在完全不修改原来的代码插件化式地添加了ServerC。在这个时候你还可以实现定时刷新配置的功能，并将新的Server打包成jar包放到指定目录，实现热更新。
当然了，java的反射机制在提供了极大的便捷的同时也带来了一定的性能损耗，我相信类似这样的插件化编程还会有很多更好的方法去实现，在这里就当是抛砖引玉了。