Java反射机制主要提供了如下功能：

l         在运行时判断任何一个对象所属的类；

l         在运行时构造任意一个类的对象；

l         在运行时判断任何一个类所具有的成员变量和方法；

l         在运行时调用任何一个对象的方法；

l         生成动态代理。

一．             Java Reflection API简介

在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中：

l         Class类：代表一个类；

l         Field类：代表类的成员变量；

l         Method类：代表类的方法；

l         Constructor：代表类的构造方法；

l         Array：提供了动态创建数组，以及访问数组元素的静态方法。

至于它们的使用，请参见我先前的一篇文章：Java反射机制学习笔记（一），在此不再赘述。

二．             在远程方法调用中运用反射机制

让我们来看一个在远程调用方法中调用运用反射机制的例子。该例的服务端SimpleServer接收客户端SimpleClient发送的Call对象，该Call类型对象包括要调用的远程对象的类名、方法名、参数类型和参数值信息。而服务端SimpleServer在接收到该对象时，调用指定类名的指定方法，并加组装了返回值的Call类型对象返回给客户端SimpleClient。若不存在所指定的类或方法，则将异常放入Call类型对象的result属性中，返回给客户端。下面让我们来看看这个例子：

1.       Call对象

Call对象包含类名、方法名、参数类型、参数值信息和返回结果信息，是用来在客户端和服务端进行信息交互的对象。其代码如下：

package remotecall;

import java.io.Serializable;
publicclass Call implements Serializable {
    //类名或接口名
    private String className;

    //方法名
    private String methodName;

    //方法参数类型
    private Class[] paramTypes;

    //方法参数值
    private Object[] params;

    //返回方法的执行结果，正常执行时，存放返回值，发生异常时，result为该异常
    private Object result;

    public Call() {   
    }

    /** *//**
     *构造函数.
     */
    public Call(String className, String methodName,
           Class[] paramTypes, Object[] params) {
       this.className = className;
       this.methodName = methodName;
       this.paramTypes = paramTypes;
       this.params = params;
    }

    //省略className、methodName、paramTypes、params和result的set/get方法
    public String toString() {
       return"className=" + className + "，methodName=" + methodName;
    }
}

 2.       服务端SimpleServer

服务端建立一个ServerSocket，一直读取客户端发送来的消息，并传入参数到指定的方法，调用该方法，并将返回结果设置到Call类型对象的result属性中，若出现异常情况时，将异常放入result属性中，并将改变后的Call类型对象返回。其代码如下所示：

package remotecall;

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

/** *//**
 *服务端.
 */
publicclass SimpleServer {
    //存放远程对象的缓存
    private Map<String, Object> remoteObjects = new HashMap<String, Object>();
    
    /** *//**
     *将一个远程对象加入缓存中.
     *@paramclassNamemap中的key——类名
     *@paramremoteObject远程对象
     */
    publicvoid register(String className, Object remoteObject) {
       remoteObjects.put(className, remoteObject);
    }
    
    publicvoid service() throws Exception {
       ServerSocket serverSocket = new ServerSocket(8000);
       System.out.println("服务器启动");
       while(true) {
           Socket socket = serverSocket.accept();
           InputStream in = socket.getInputStream();
           ObjectInputStream ois = new ObjectInputStream(in);
           OutputStream out = socket.getOutputStream();
           ObjectOutputStream oos = new ObjectOutputStream(out);

           //接收从客户端发送的Call对象
           Call call = (Call) ois.readObject();
           //调用call的toString()方法打出className和methodName
           System.out.println(call);
           //调用对象的相关方法
           call = invoke(call);
           //将放置了result值的对象放入输出中返回
           oos.writeObject(call);

           //关闭相关资源
           ois.close();
           oos.close();
           socket.close();
       }
    }

    /** *//**
     *调用远程方法的指定方法，并将返回值放入call对象的result中.
     *@paramcall调用对象
     *@return返回设置了result值的call对象
     */
    public Call invoke(Call call) {
       Object result = null;
       try {
           //取出对象中的各参数
           String className = call.getClassName();
           String methodName = call.getMethodName();
           Class[] paramTypes = call.getParamTypes();
           Object[] params = call.getParams();
           
           //获取类
           Class classType = Class.forName(className);
           //获取方法
           Method method = classType.getMethod(methodName, paramTypes);
           //将className作为key在map中取出远程对象
           Object remoteObject = remoteObjects.get(className);
           if (remoteObject == null) {
              thrownew Exception(className + "远程对象不存在!");
           } else {
              //通过传入相应参数调用remoteObject的指定方法
              //并将返回值放入result中.
              result = method.invoke(remoteObject, params);
           }
       } catch(Exception e) {
           result = e;
       }

       //设置返回值
       call.setResult(result);
       return call;
    }

    /** *//**
     *测试方法.
     */
    publicstaticvoid main(String[] args) throws Exception {
       SimpleServer server = new SimpleServer();
       //存放对象到remoteObjects这个map中
       server.register("remotecall.HelloService", new HelloServiceImpl());
       server.service();
    }
}

 3.    客户端SimpleClient

客户端发送组装好的Call对象给服务端，并读取指定方法的返回结果。其完整代码如下：

package remotecall;

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

/** *//**
 *客户端类.
 */
publicclass SimpleClient {
    publicvoid invoke(Call call) throws Exception {
       Socket socket = new Socket("localhost", 8000);
       OutputStream out = socket.getOutputStream();
       ObjectOutputStream oos = new ObjectOutputStream(out);
       InputStream in = socket.getInputStream();
       ObjectInputStream ois = new ObjectInputStream(in);  

       //向服务器发送call对象
       oos.writeObject(call);
       //接收从服务端发送回的对象
       call = (Call) ois.readObject();
       //打印结果信息
       System.out.println(call.getResult());

       //关闭资源
       ois.close();
       oos.close();
       socket.close();
    }
   
    /** *//**
     *测试方法.
     */
    publicstaticvoid main(String[] args) throws Exception {
       SimpleClient client = new SimpleClient();

       //构建一个正确Call对象
       Call call = new Call();
       call.setClassName("remotecall.HelloService");
       call.setMethodName("echo");
       call.setParamTypes(new Class[]{String.class});
       call.setParams(new Object[]{"Hello，阿蜜果"});
       client.invoke(call);
       
       //构建一个错误的Call对象（不存在所指定的类）
       call.setClassName("remotecall.HelloEcho");
       client.invoke(call);
    }
}

4.    远程类HelloService及其实现类HelloServiceImpl

为了测试上面的功能，还需要模拟一个远程对象所属的类，本例的HelloService接口具有两个方法，echo()和getTime()。两者的内容如下：

HelloService的内容:

package remotecall;

import java.util.Date;

publicinterface HelloService {
    public String echo(String msg);

    public Date getTime();
}

HelloServiceImpl的内容：

package remotecall;

import java.util.Date;

publicclass HelloServiceImpl implements HelloService {
    public String echo(String msg) {
       return"echo： " + msg;
    }

    public Date getTime() {
       returnnew Date();
    }
}

    在测试时，我们首先运行服务端SimpleServer，将服务端启动起来，接着将客户端SimpleClient启动，可在控制台看到如下信息：

客户端的信息如下：

echo： Hello，阿蜜果

java.lang.ClassNotFoundException: remotecall.HelloEcho

服务端的信息如下：

服务器启动...

className=remotecall.HelloService，methodName=echo

className=remotecall.HelloEcho，methodName=echo

三．代理模式

代理模式是常用的Java设计模式，它的特征是代理类和委托类有相同的接口。代理类主要负责为委托类预处理消息、过滤信息、把消息转发给委托类，以及事后处理信息等。代理类和委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

根据代理类的创建时期，可将其分为两类：

l         静态代理类：由程序员创建或由特定工具自动生成源代码；

l         动态代理类：在程序运行时，运用反射机制创建而成。

1.    静态代理类

请参考代理模式的一些实现实例，在此不再详述。

2.    动态代理类

动态代理类不仅简化了编程工作，而且提高了软件系统的扩展性，因为Java反射机制可以生成任意类型的动态代理类。java.lang.reflect类和InvocationHandler接口提供了生成动态代理类的能力。与之相关的方法是：getProxyClass()和newProxyInstance()方法。下面让我们来看一个动态代理类的简单例子：

package proxy;

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

/** *//**
 *动态代理类.
 */
publicclass HelloServiceProxyFactory {
    publicstatic HelloService getHelloServiceProxy(final HelloService helloService) {
       InvocationHandler handler = new InvocationHandler() {
           public Object invoke(Object proxy, Method method, Object args[])
                  throws Exception {
              System.out.println("before calling " + method);
              Object result = method.invoke(helloService, args);
              System.out.println("after calling " + method);
              return result;
           }
       };
       
       Class classType = HelloService.class;
       return (HelloService) Proxy.newProxyInstance(classType.getClassLoader(),
              new Class[]{classType},
              handler);
    }

    /** *//**
     *测试方法.
     */
    publicstaticvoid main(String[] args) {
       HelloService helloService = new HelloServiceImpl();
       HelloService helloServiceProxy = HelloServiceProxyFactory.getHelloServiceProxy(
              helloService);
       System.out.println("代理类名字：" + helloServiceProxy.getClass().getName());
       System.out.println(helloService.echo("Hello,阿蜜果"));
    }
}

     运行后可看到这个代理类是动态生成的。在Spring的AOP中也运到了动态代理机制，有兴趣的朋友可查找相关资料。