假定在SimpleServer 服务器端创建了一个HelloServiceImpl对象,它具有getTime()
和echo()方法。HelloServiceImpl类实现了HelloService接口
远程方法调用先定义接口及其实现,
package reflection.rmi;
import java.util.Date;
public interface HelloService {//服务接口
public String echo(String msg);
public Date getTime();
}
package reflection.rmi;
import java.util.Date;
public class HelloServiceImpl implements HelloService { //服务类
public String echo(String msg) {
return "echo:" + msg;
}
public Date getTime() {
return new Date();
}
}
SimpleClient客户端如何调用服务器端的HelloServiceImpl对象的getTime()和echo()
方法呢?显然,SimpleClient客户端需要把调用的方法名、方法参数类型、方法参数值,
以及方法所属的类名或接口名发送给SimpleServer,SimpleServer 再调用相关对象的方
法,然后把方法的返回值发送给SimpleClient。
为了便于按照面向对象的方式来处理客户端与服务器端的通信,可以把它们发送
的信息用Call 类(如例程10-8所示)来表示。一个Call对象表示客户端发起的一个远
程调用,它包括调用的类名或接口名、方法名、方法参数类型、方法参数值和方法执
行结果。
例程10-8Call.javapackage reflection.rmi;
import java.io.*;
public class Call implements Serializable { // 可串口化的对象
private String className; // 表示类名或接口名
private String methodName; // 表示方法名
private Class[] paramTypes; // 表示方法参数类型,用于getMethod方法
private Object[] params; // 表示方法参数值,用于invoke方法
// 表示方法的执行结果
// 如果方法正常执行,则result 为方法返回值,如果方法抛出异常,那么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;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public Class[] getParamTypes() {
return paramTypes;
}
public void setParamTypes(Class[] paramTypes) {
this.paramTypes = paramTypes;
}
public Object[] getParams() {
return params;
}
public void setParams(Object[] params) {
this.params = params;
}
public Object getResult() {
return result;
}
public void setResult(Object result) {
this.result = result;
}
public String toString() {
return "className=" + className + " methodName=" + methodName;
}
}
SimpleClient 调用SimpleServer 端的HelloServiceImpl 对象的echo()方法的流程
如下。
(1)SimpleClient 创建一个Call 对象,它包含了调用HelloService 接口的echo()
方法的信息。
(2)SimpleClient通过对象输出流把Call对象发送给SimpleServer。
(3)SimpleServer 通过对象输入流读取Call 对象,运用反射机制调用
HelloServiceImpl对象的echo()方法,把echo()方法的执行结果保存到Call对象中。
(4)SimpleServer 通过对象输出流把包含了方法执行结果的Call 对象发送给
SimpleClient。
(5)SimpleClient通过对象输入流读取Call对象,从中获得方法执行结果。
如例程10-9 和例程10-10 所示分别是SimpleServer 和SimpleClient 的源程序。
客户端代码例程10-10 SimpleClient.java
package reflection.rmi;
import java.io.*;
import java.net.*;
import java.util.*;
public class SimpleClient {
public void invoke() throws Exception {
Socket socket = new Socket("localhost", 8888);
OutputStream out = socket.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
InputStream in = socket.getInputStream();
ObjectInputStream ois = new ObjectInputStream(in);
// Call call=new Call("remotecall.HelloService","getTime",
// new Class[]{},new Object[]{});
Call call = new Call("reflection.rmi.HelloService", "echo",
new Class[] { String.class }, new Object[] { "Hello" });
oos.writeObject(call); // 向服务器发送Call 对象
call = (Call) ois.readObject(); // 接收包含了方法执行结果的Call 对象
System.out.println(call.getResult());
ois.close();
oos.close();
socket.close();
}
public static void main(String args[]) throws Exception {
new SimpleClient().invoke();
}
}
服务器端代码:例程10-9 SimpleServer.java
package reflection.rmi;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.reflect.*;
public class SimpleServer {
private Map remoteObjects = new HashMap(); // 存放远程对象的缓存
/** 把一个远程对象放到缓存中 */
public void register(String className, Object remoteObject) {
remoteObjects.put(className, remoteObject);
}
public void service() throws Exception {
ServerSocket serverSocket = new ServerSocket(8888);
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) ois.readObject(); // 接收客户发送的Call 对象
System.out.println(call); // toString()方法
call = invoke(call); // 调用相关对象的方法
oos.writeObject(call); // 向客户发送包含了执行结果的Call 对象
ois.close();
oos.close();
socket.close();
}
}
public Call invoke(Call call) {
Object result = null;
try {
String className = call.getClassName();
String methodName = call.getMethodName();
Object[] params = call.getParams();
Class classType = Class.forName(className);
Class[] paramTypes = call.getParamTypes();
Method method = classType.getMethod(methodName, paramTypes);
Object remoteObject = remoteObjects.get(className); // 从缓存中取出相关的远程对象
if (remoteObject == null) {
throw new Exception(className + "的远程对象不存在");
} else {
result = method.invoke(remoteObject, params);
}
} catch (Exception e) {
result = e;
}
call.setResult(result); // 设置方法执行结果
return call;
}
public static void main(String args[]) throws Exception {
SimpleServer server = new SimpleServer();
// 把事先创建的HelloServiceImpl 对象加入到服务器的缓存中
server.register("reflection.rmi.HelloService", new HelloServiceImpl());
server.service();
}
}
先运行命令“java reflection.rmi.SimpleServer”,再运行命令“java reflection.rmi.SimpleClient”,SimpleClient 端将打印“echo:Hello”。该打印结果是服务器端执行HelloServiceImpl 对象的echo()方法的返回值
如下图所示:
- 大小: 9.3 KB
- 大小: 6.5 KB
- 大小: 5.8 KB
分享到:
相关推荐
最后,文章中提到了一个远程方法调用的例子,其中客户端通过反射机制的动态代理功能远程调用服务器端对象的方法。这个例子展示了Java反射机制在分布式计算中的应用,说明了反射在实现远程方法调用方面的重要性。 总...
通过`Remote.class.getMethod()`获取该方法的`Method`对象,这是因为RMI底层使用了反射机制来实现远程方法调用。 ```java private static Method $method_getMemberAccountCount_5; static { try { $method_...
这样,客户端可以远程调用服务器端的一个对象的方法。 Java 反射机制是一个强大且灵活的功能,它可以帮助开发者在运行时动态地获取类的信息和调用对象的方法,从而提高了 Java 语言的编程灵活性和开发效率。
Java反射机制允许程序在运行时检查类的内部结构,包括类名、包信息、属性、方法、注解等。此外,它还可以动态地创建对象并调用它们的方法,即使在编译时不知道具体的类名。反射的核心是`java.lang.Class`类,它代表...
首先,Java的反射机制允许我们在运行时检查类的信息,包括类名、属性、方法以及构造器等,并能动态地创建对象和调用方法。这主要通过`java.lang.Class`类和`java.lang.reflect`包中的相关API实现。例如,我们可以...
本章首先介绍了Java Reflection API的用法,然后介绍了一...这个例子中客户端能够远程调用服务器端的一个对象的方法。服务器端采用了反射机制提供 的动态调用方法的功能,而客户端则采用了反射机制提供的动态代理功能。
本章首先介绍了Java Reflection API的用法,然后介绍了一个远程方法调用的例子,在这个例子中客户端能够远程调用服务器端的一个对象的方法。服务器端采用了反射机制提供的动态调用方法的功能,而客户端则采用了反射...
在实际应用中,反射技术常用于序列化、数据绑定、远程方法调用以及对象/关系数据映射等场景。现代软件开发中,动态获取和操纵类型信息已经成为了标志性的需求。 对于C++来说,添加反射机制的可能方式有多种,根据...
Java反射是Java编程语言中的一个强大特性,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中,反射机制的核心类包括`Class`、`Field`、`Method`和`Constructor`,它们分别代表类、...
这个"Java_Reflection_Programming.rar_Agent_java programming_反射"压缩包包含了关于Java反射机制的深入讲解,以及其在远程方法调用和代理模式中的应用。 首先,Reflection API是Java标准库中的一个关键部分,...
Java反射API主要包括以下几个核心类: 1. **Class类**:每个类在JVM中都有一个对应的Class对象,它包含了类的所有信息。我们可以通过`Class.forName()`或者对象的`getClass()`方法来获取对应的Class对象。 2. **...
反射技术的应用领域有很多,例如远程调用:客户端利用 socket 与服务端通信,发送要调用的类的方法和参数等信息,然后服务端利用反射技术调用指定的函数,返回结果给客户端。另外,反射技术也可以用来实现动态代理、...
1. **Java反射机制**:Java反射是Java语言的一个强大功能,它允许程序在运行时动态地获取类的信息并操作类的对象。在这个RPC框架中,反射用于在客户端和服务器端之间动态调用服务方法。通过类名和方法名,反射可以...
使用Java语言调用终端开启关闭Nginx服务器,然后执行ffmpeg命令,开启转流推流。以及其它指令,来学习吧
3. **生成动态代理**:这是反射机制的一个高级应用,允许我们创建一个接口的代理实例,用于拦截并处理对该接口方法的调用,常用于AOP(面向切面编程)和RPC(远程过程调用)等场景。 #### Java Reflection API简介 ...