Nous allons introduire la réflexion de l'application dans la programmation réseau, comment appeler une implémentation côté serveur du client par des méthodes à distance.
En supposant une interface de serveur de HelloService, l'interface ayant procédé getTime () et echo (), le code spécifique est la suivante:
import java.util.Date;
public interface HelloService {
public String echo(String msg);
public Date getTime();
}
HelloServiceImpl créer une classe sur le serveur et mettre en œuvre l'interface HelloService. HelloServiceImpl code de classe suit comme:
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();
}
}
Comme le montre le code ci-dessus dans la classe de méthode HelloServiceImpl écho () et la méthode getTime () a été réécrite. Alors, comment appeler le serveur client Bonjour-ServiceImpl classe getTime () et echo () méthodes?
La méthode spécifique est : la classe ou le nom de l' interface client expéditeur doit invoquer le nom de la méthode, le type de paramètre de procédé, la méthode de la valeur de paramètre, et une méthode appartient au serveur. méthode côté serveur, puis appelez l'objet concerné, et la valeur de retour de la méthode est envoyé au client.
Afin de faciliter de manière orientée objet selon poignée de communication client et le serveur, les informations peuvent être transmises à leur disposition par la classe d'appel représenté. Un objet d'appel représente un appel à distance initiée par le client, ce qui comprend l'appel d'un nom de classe ou interface, le nom de méthode, des types de paramètres, des méthodes, des paramètres et des procédés de résultats d'exécution.
codes de classe d'appel sont les suivants:
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;
}
}
On suppose que le client est SimpleClient, le serveur est SimpleServer. Objets HelloServiceImpl procédé flux d'appels SimpleClient en SimpleServer echo () est la suivante:
1. SimpleClient créer un objet d'appel contenant l'appel de l'information de procédé Interface HelloService echo ().
2. Sortie de flux SimpleClient à travers l'objet pour envoyer l'objet Call SimpleServer.
3. SimpleServer objet d'appels par la lecture du flux d'entrée d'objet, en utilisant HelloServiceImpl appel d'objet de la réflexion de la méthode () pour enregistrer les résultats de la méthode d'exécution d'écho () de l'objet de l'appel.
4. SimpleServer SimpleClient à travers l'objet d'envoyer le flux de sortie comprend la réalisation de la méthode résulte objet d'appel.
5. SimpleClient objet d'appels en lisant le flux d'entrée des objets, un procédé pour l'obtention d'un résultat d'exécution de celle-ci.
Tout d'abord, regardons le code qui implémente la classe programme client 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();
}
}
Comme le montre le code ci-dessus, le rôle principal est client des classes de SimpleClient établissent une connexion avec le serveur, puis appelez l'objet d'appel avec les informations transmises au serveur.
serveur de classe SimpleServer après avoir reçu la demande d'appel utilise la réflexion pour invoquer la méthode spécifiée de l'objet dynamique spécifié, puis renvoie le résultat de l'exécution au client.
codes de classe SimpleServer sont les suivantes:
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();
}
}
Comme il s'agit d'une application Web, vous devez d'abord côté serveur d'exécution SimpleServer, puis exécutez le client SimpleClient. Le résultat est en cours d'exécution sur le client de voir la sortie « echoJava », le résultat est la valeur de retour procédé de mise en oeuvre côté serveur écho objet HelloServicelmpl (). La figure suivante montre le processus de communication avec SimpleClient SimpleServer.
