前言
RPC的大多数实现方式包括两类：Socket与Netty，接下来介绍两种方式基于java的简单实现。
RPC架构分为三部分：
1）服务提供者，运行在服务器端，提供服务接口定义与服务实现类。
2）服务中心，运行在服务器端，负责将本地服务发布成远程服务，管理远程服务，提供给服务消费者使用。
3）服务消费者，运行在客户端，通过远程代理对象调用远程服务。
1 Socket
RPC的socket实现是基于TCP/IP协议，它在通信的两端各建立一个Socket，从而在通信的两端之间形成网络虚拟链路。一旦建立了虚拟的网络链路，两端的成员就可以通过虚拟链路进行通信。Java是对基于TCP协议的网络通信提供了良好的封装，Java使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信，实现消费者与服务方的通信。
1.1 Interface
首先介绍接口类中的接口方法：
SayHello.java
public interface SayHello {
String sayHello(String name);
}Server.java
import java.io.IOException;
public interface Server {
void stop();
void start() throws IOException;
void register(Class serviceInterface, Class impl);
boolean isRunning();
int getPort();
}1.2 Provider
服务端定义接口的具体实现，包括被调用方法以及服务中心实现。
SayHelloImpl.java
/**
* @author jhz
* @date 18-8-24 下午8:56
*/
public class SayHelloImpl implements SayHello{
@Override
public String sayHello(String name) {
return name;
}
}
ServerImpl.java
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;
/**
* @author jhz
* @date 18-8-24 下午10:00
*/
public class ServerImpl implements Server {
private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
private static final HashMap<String, Class> serviceRegistry = new HashMap<String, Class>();
private static boolean isRunning = false;
private static int port;
public ServerImpl(int port) {
this.port = port;
}
public void stop() {
isRunning = false;
executor.shutdown();
}
public void start() throws IOException {
ServerSocket server = new ServerSocket();
server.bind(new InetSocketAddress(port));
System.out.println("start server");
try {
while (true) {
// 1.监听客户端的TCP连接，接到TCP连接后将其封装成task，由线程池执行
executor.execute(new ServiceTask(server.accept()));
}
} finally {
server.close();
}
}
public void register(Class serviceInterface, Class impl) {
serviceRegistry.put(serviceInterface.getName(), impl);
}
public boolean isRunning() {
return isRunning;
}
public int getPort() {
return port;
}
private static class ServiceTask implements Runnable {
Socket clent = null;
public ServiceTask(Socket client) {
this.clent = client;
}
public void run() {
ObjectInputStream input = null;
ObjectOutputStream output = null;
try {
// 2.将客户端发送的码流反序列化成对象，反射调用服务实现者，获取执行结果
input = new ObjectInputStream(clent.getInputStream());
String serviceName = input.readUTF();
String methodName = input.readUTF();
Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
Object[] arguments = (Object[]) input.readObject();
Class serviceClass = serviceRegistry.get(serviceName);
if (serviceClass == null) {
throw new ClassNotFoundException(serviceName + " not found");
}
Method method = serviceClass.getMethod(methodName, parameterTypes);
Object result = method.invoke(serviceClass.newInstance(), arguments);
// 3.将执行结果反序列化，通过socket发送给客户端
output = new ObjectOutputStream(clent.getOutputStream());
output.writeObject(result);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (output != null) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (input != null) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (clent != null) {
try {
clent.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}
ProviderRunner.java(服务端启动)
import java.io.IOException;
/**
* @author jhz
* @date 18-8-24 下午10:40
*/
public class ProviderRunner {
public static void main(String[] args) {
new Thread(new Runnable() {
public void run() {
try {
Server serviceServer = new ServerImpl(8088);
serviceServer.register(SayHello.class, SayHelloImpl.class);
serviceServer.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
}
1.3 Consumer
RPCClient.java(客户端代理类)
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;
/**
* @author jhz
* @date 18-8-24 下午10:10
*/
public class RPCClient {
public static <T> T getRemoteProxyObj(final Class<?> serviceInterface, final InetSocketAddress addr) {
// 1.将本地的接口调用转换成JDK的动态代理，在动态代理中实现接口的远程调用
return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[]{serviceInterface},
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Socket socket = null;
ObjectOutputStream output = null;
ObjectInputStream input = null;
try {
// 2.创建Socket客户端，根据指定地址连接远程服务提供者
socket = new Socket();
socket.connect(addr);
// 3.将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
output = new ObjectOutputStream(socket.getOutputStream());
output.writeUTF(serviceInterface.getName());
output.writeUTF(method.getName());
output.writeObject(method.getParameterTypes());
output.writeObject(args);
// 4.同步阻塞等待服务器返回应答，获取应答后返回
input = new ObjectInputStream(socket.getInputStream());
return input.readObject();
} finally {
if (socket != null) socket.close();
if (output != null) output.close();
if (input != null) input.close();
}
}
});
}
}
可以看到远程的调用是在动态处理器中的invoke()方法（匿名类中的invoke）中实现的，且是同步阻塞的实现方式，当客户端发起调用时，在invoke()中发起创建socket连接，等待服务端返回调用结果。
SocketRunner.java(调用类)
import java.io.IOException;
import java.net.InetSocketAddress;
/**
* @author jhz
* @date 18-8-24 下午10:19
*/
public class SocketRunner {
public static void main(String[] args) throws IOException {
SayHello service = RPCClient.getRemoteProxyObj(SayHello.class, new InetSocketAddress("localhost", 8088));
System.out.println(service.sayHello("hello jhz!"));
}
}
运行结果
首先启动服务端
再启动客户端：
2 Netty
接着我们使用Netty来代替这种BIO的实现：
2.1 Interface
接口类只需要定义接口方法（SayHello），服务端中的实现方法也不用变
2.2 Provider
NettyServer.java（Netty服务端）
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
/**
* @author jhz
* @date 18-8-24 下午10:48
*/
public class NettyServer {
public static void startServer(String hostName, int port) {
try {
ServerBootstrap bootstrap = new ServerBootstrap();
NioEventLoopGroup eventLoopGroup = new NioEventLoopGroup();
bootstrap.group(eventLoopGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast(new StringDecoder());
p.addLast(new StringEncoder());
p.addLast(new HelloServerHandler());
}
});
bootstrap.bind(hostName, port).sync();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
在NettyServer中定义ServerBootStrap,并添加自定义的handler，具体的实现如下：
HelloServerHandler.java
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
/**
* @author jhz
* @date 18-8-26 上午12:40
*/
public class HelloServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
// 如何符合约定，则调用本地方法，返回数据
if (msg.toString().startsWith("SayHello")) {
String result = new SayHelloImpl()
.sayHello(msg.toString().substring(msg.toString().lastIndexOf("#") + 1));
ctx.writeAndFlush(result);
}
}
}
该类重写channelRead以实现对channel中消息的过滤以及具体方法的调用。
NettyServerStarter.java
/**
* @author jhz
* @date 18-8-26 上午12:23
*/
public class NettyServerStarter {
public static void main(String[] args) {
NettyServer.startServer("localhost", 8088);
System.out.println("Netty Server Start!");
}
}
2.2 Consumer
同样，我们需要创建客户端代理类
RPCConsumer.java
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import java.lang.reflect.Proxy;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author jhz
* @date 18-8-26 上午12:19
*/
public class RPCConsumer {
private static ExecutorService executor = Executors
.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
private static SayHelloHandler client;
/**
* 创建一个代理对象
*/
public Object createProxy(final Class<?> serviceClass,
final String providerName) {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class<?>[]{serviceClass}, (proxy, method, args) -> {
if (client == null) {
initClient();
}
// 设置参数
client.setPara(providerName + args[0]);
return executor.submit(client).get();
});
}
/**
* 初始化客户端
*/
private static void initClient() {
client = new SayHelloHandler();
EventLoopGroup group = new NioEventLoopGroup();
Bootstrap b = new Bootstrap();
b.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast(new StringDecoder());
p.addLast(new StringEncoder());
p.addLast(client);
}
});
try {
b.connect("localhost", 8088).sync();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
在代理中实现客户端的初始化，定义ClientBootStrap并添加客户端的自定义handler(SayHelloHandler)，这个handler同时还能在收到回复后完成callback，SayHelloHandler的具体实现如下。
ClientHandler.java
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import java.util.concurrent.Callable;
public class SayHelloHandler extends ChannelInboundHandlerAdapter implements Callable {
private ChannelHandlerContext context;
private String result;
private String para;
@Override
public void channelActive(ChannelHandlerContext ctx) {
context = ctx;
}
/**
* 收到服务端数据，唤醒等待线程
*/
@Override
public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) {
result = msg.toString();
notify();
}
/**
* 写出数据，开始等待唤醒
*/
@Override
public synchronized Object call() throws InterruptedException {
context.writeAndFlush(para);
wait();
return result;
}
void setPara(String para) {
this.para = para;
}
}定义了ChannelHandlerContext context：缓存ctx，可以用于下次使用，整个流程如下，客户端发起调用->调用call()方法，将请求消息写入channel并等待唤醒->收到服务端返回的消息调用channelRead()并唤醒call上等待的线程，返回结果。
ClientBootStrap.java(客户端测试类)
/**
* @author jhz
* @date 18-8-26 上午12:12
*/
public class ClientBootStrap {
public static final String providerName = "SayHello#sayHello#";
public static void main(String[] args) throws InterruptedException {
RPCConsumer consumer = new RPCConsumer();
// 创建一个代理对象
SayHello service = (SayHello) consumer
.createProxy(SayHello.class, providerName);
System.out.println(service.sayHello("hello jhz"));
}
}
测试结果
启动Netty服务端：
客户端调用：
采用Netty实现的RPC是线程级别的阻塞，并不会影响到其他的线程。
扫一扫
1635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
