Vamos a introducir el reflejo aplicación en red de programación, cómo llamar a una aplicación del lado del servidor del cliente mediante métodos remotos.
Suponiendo una interfaz de servidor HelloService, la interfaz que tiene echo () método getTime (), y el código específico es el siguiente:
import java.util.Date;
public interface HelloService {
public String echo(String msg);
public Date getTime();
}
HelloServiceImpl crear una clase en el servidor y ejecutar la interfaz HelloService. código de clase HelloServiceImpl de la siguiente manera:
import java.util.Date;
public class HelloServiceImpl implements HelloService {
@Override
public String echo(String msg) {
return "echo:" + msg;
}
@Override
public Date getTime() {
return new Date();
}
}
Como se muestra en el código anterior en la clase de método HelloServiceImpl echo () y el método getTime () se ha reescrito. Por lo tanto, la forma de llamar al servidor de cliente Hola-ServiceImpl clase getTime () y echo () métodos?
El método específico es : la clase o interfaz nombre de cliente que envía necesita invocar el nombre del método, el método de tipo de parámetro, el método de valor de parámetro, y un método pertenece al servidor. Método del lado del servidor y luego llamar al objeto pertinente, y luego el valor de retorno del método se envía al cliente.
Para facilitar manera orientada a objetos de acuerdo con la manija cliente de comunicaciones y el servidor, la información puede ser transmitida a ellos por la clase de llamada representado. Un llamado objeto representa una llamada remota iniciada por el cliente, que incluye llamar a una clase o interfaz nombre, el nombre del método, los tipos de parámetros, métodos, parámetros y métodos de resultados de la ejecución.
códigos de clase de llamadas son los siguientes:
import java.io.Serializable;
public class Call implements Serializable {
private static final long serialVersionUID = 6659953547331194808L;
private String className; // 表示类名或接口名
private String methodName; // 表示方法名
private Class[] paramTypes; // 表示方法参数类型
private Object[] params; // 表示方法参数值
// 表示方法的执行结果
// 如果方法正常执行，则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;
}
}
Supongamos que el cliente es SimpleClient, el servidor es SimpleServer. HelloServiceImpl objetos de flujo de llamada SimpleClient en SimpleServer echo () método es como sigue:
1. SimpleClient crear un eco método HelloService interfaz () objeto llamada que contiene información de la llamada.
2. SimpleClient salida de la corriente a través del objeto para enviar el SimpleServer objeto de llamadas.
3. SimpleServer objeto de llamadas mediante la lectura de la corriente de entrada de objeto, utilizando el método de la reflexión de eco HelloServiceImpl llamada a un objeto () para guardar los resultados de la ejecución de eco () método del objeto de llamada.
4. SimpleServer SimpleClient a través del objeto de enviar los comprende flujo de salida que realizan el método resulta objeto de llamadas.
5. SimpleClient llamada de objeto mediante la lectura de la corriente de objetos de entrada, un método para obtener una de ellas resultado de la ejecución.
En primer lugar, vamos a ver el código que implementa la clase SimpleClient programa cliente.
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.reflect.*;
import java.io.*;
import java.net.*;
import java.util.*;
public class SimpleClient {
public void invoke() 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 call = new Call("ch12.HelloService", "echo", new Class[] { String.class }, new Object[] { "Java" });
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();
}
}
Como se muestra en el código anterior, el papel principal es clases SimpleClient cliente establecen una conexión con el servidor, y luego llamar al objeto de llamada a la información transmitida al servidor.
servidor de clase SimpleServer después de recibir la solicitud de llamada utiliza la reflexión para invocar el método especificado de objeto especificado dinámicamente, y devuelve el resultado de la ejecución para el cliente.
SimpleServer códigos de clase son las siguientes:
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(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) ois.readObject(); // 接收客户发送的Call对象
System.out.println(call);
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("ch13.HelloService", new HelloServiceImpl());
server.service();
}
}
Dado que se trata de una aplicación web, primero tiene que del lado del servidor de ejecución SimpleServer, y luego ejecutar el cliente SimpleClient. El resultado se está ejecutando en el cliente para ver la salida "echoJava", el resultado es el eco del lado del servidor objeto de implementación HelloServicelmpl valor de retorno () del método. La siguiente figura muestra la SimpleClient proceso de comunicación con SimpleServer.
