版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u013817676/article/details/84255587
客户端通过定义接口,通过动态代理的方式向服务端请求运行结果,服务端通过解析字符串,来解析所要调用接口、方法、参数,并将接口实现的结果通过Socket的方式返回给客户端。
1. 服务端将接口通过map的方式映射成方法名和接口类,并启动socket连接。
package server;
public interface ServerCenter {
public void start();
public void stop();
public void register(Class service , Class serviceImpl);
}
package serverImpl;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import server.ServerCenter;
public class ServerCenterImpl implements ServerCenter {
private final int port = 12000;
@SuppressWarnings("rawtypes")
private static ConcurrentHashMap<String, Class> register = new ConcurrentHashMap<>();
// 连接池:连接池中存在多个连接对象,每个对象都可以处理一个客户请求
private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// 是否启动线程
private static boolean isRunning = false;
@SuppressWarnings("resource")
@Override
public void start() {
ServerSocket server = null;
try {
server = new ServerSocket();
server.bind(new InetSocketAddress(port));
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
isRunning = true;
System.out.println("开启服务线程...");
while (true) {
Socket socket = null;
try {
socket = server.accept();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
executor.execute(new ServiceTask(socket));
}
}
// 关停请求线程
@Override
public void stop() {
// 如果有线程运行,则关闭
if (isRunning) {
executor.shutdown();
}
}
// 注册服务
@Override
public void register(Class service, Class serviceImpl) {
register.put(service.getName(), serviceImpl);
}
private static class ServiceTask implements Runnable {
private Socket socket;
public ServiceTask(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
ObjectInputStream input = null;
ObjectOutputStream output = null;
try {
// 等待客户端连接
input = new ObjectInputStream(socket.getInputStream());
// 序列流需要顺序接收解析
String serviceName = input.readUTF();
String methodName = input.readUTF();
@SuppressWarnings("rawtypes")
Class[] parametersTypes = (Class[]) input.readObject();
Object[] args = (Object[]) input.readObject();
// 根据client请求找到具体接口
Class<?> serviceClass = register.get(serviceName);
// 根据方法名和参数类型获取方法
Method method = serviceClass.getMethod(methodName, parametersTypes);
// 执行方法
Object res = method.invoke(serviceClass.newInstance(), args);
// 返回结果
output = new ObjectOutputStream(socket.getOutputStream());
output.writeObject(res);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (input != null) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (output != null) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}
2. 客户端与服务端建立连接,通过JDK动态代理方式将请求的接口名、方法名、参数类型、参数列表发送给服务端。服务端解析这些字段,调用服务端的接口实现,将结果返回给客户端。
package client;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;
public class Client {
@SuppressWarnings("unchecked")
public static <T> T getRemoteProxyRes(Class<?> serviceInterface,InetSocketAddress addr){
/**
* 1. 类加载器 classLoader: 加载需要代理的类(HelloServic接口)
* 2. 需要代理对象,具有哪些功能 接口
* 3.
*/
return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[] {serviceInterface} , new InvocationHandler() {
/*
* (non-Javadoc)
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
* proxy: 代理对象
* method: 哪个方向
* args :参数列表
*/
@Override
public Object invoke(Object proxy , Method method, Object[] args)
throws Throwable {
ObjectOutputStream output = null;
ObjectInputStream input = null;
@SuppressWarnings("resource")
Socket socket = new Socket();
socket.connect(addr);
try {
// 发送信息
output = new ObjectOutputStream(socket.getOutputStream());
// 接口名
output.writeUTF(serviceInterface.getName());
// 方法名
output.writeUTF(method.getName());
// 参数类型
output.writeObject(method.getParameterTypes());
// 参数列表
output.writeObject(args);
// 等待服务器处理...
// 读取服务器返回的结果
input = new ObjectInputStream(socket.getInputStream());
return input.readObject();
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
if (input != null){
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (output != null){
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
});
}
}