Vamos introduzir a reflexão aplicação na rede de programação, como chamar uma implementação do lado do servidor do cliente por meio de métodos remotos.
Assumindo uma interface de servidor HelloService, a interface tendo getTime () e método de eco (), o código específico é como se segue:
import java.util.Date;
public interface HelloService {
public String echo(String msg);
public Date getTime();
}
HelloServiceImpl criar uma classe no servidor e implementar a interface HelloService. código de classe HelloServiceImpl da seguinte forma:
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 mostrado no código acima na classe do método getTime () método HelloServiceImpl eco () e foi reescrita. Então, como chamar o cliente servidor Olá-ServiceImpl classe getTime () e echo métodos ()?
O método específico é : a classe ou interface nome do cliente enviando precisa invocar o nome do método, método de tipo de parâmetro, o método valor do parâmetro, e um método pertence ao servidor. método do lado do servidor e, em seguida, chamar o objeto relevante e, em seguida, o valor de retorno do método é enviado para o cliente.
Para facilitar maneira orientada a objeto de acordo com o cliente de comunicações alça e servidor, a informação pode ser transmitida a eles pela classe chamada representados. A Call objeto representa uma chamada remota iniciada pelo cliente, o que inclui chamando uma classe ou interface nome, o nome do método, tipos de parâmetro, métodos, parâmetros e métodos de resultados da execução.
códigos de classe chamada são os seguintes:
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;
}
}
Suponha que o cliente é SimpleClient, o servidor é SimpleServer. HelloServiceImpl objectos de fluxo de chamadas SimpleClient em SimpleServer eco () método é como se segue:
1. SimpleClient criar uma interface de eco método HelloService () objeto Chamada contendo informações ligue.
2. fluxo SimpleClient saída através do objeto para enviar o objeto de chamada SimpleServer.
3. SimpleServer chamada de objeto através da leitura do fluxo de entrada de objeto, usando o método da reflexão echo chamada de objeto HelloServiceImpl () para salvar a execução resultados echo () método do objeto de chamada.
4. SimpleServer SimpleClient através do objecto a enviar os compreende fluxo de saída que executam o método resulta objecto de chamadas.
5. SimpleClient chamada de objeto através da leitura do fluxo de entrada objetos, um método para a obtenção de um resultado daí execução.
Primeiro, vamos olhar para o código que implementa o cliente classe programa SimpleClient.
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 mostrado no código acima, o papel principal é as classes SimpleClient cliente estabelecer uma conexão com o servidor, e, em seguida, chamar o objeto de chamada com a informação transmitida para o servidor.
servidor classe SimpleServer depois de receber o pedido de chamada usa reflexão para chamar o método especificado de objeto especificado de forma dinâmica, e em seguida, retorna o resultado da execução para o cliente.
códigos de classe SimpleServer são os seguintes:
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();
}
}
Uma vez que esta é uma aplicação web, você primeiro precisa server-side prazo SimpleServer, e depois executar o cliente SimpleClient. O resultado está em execução no cliente para ver a saída "echoJava", o resultado é o eco do lado do servidor implementação HelloServicelmpl objeto () valor de retorno do método. Os seguintes figura mostra o SimpleClient processo de comunicação com SimpleServer.
