架构的演进
RPC
《Dubbo+Zookeeper入门（上篇）》中用一张图解释了RPC的基本原理，这里再进一步了解RPC：
RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。首先，调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。在服务器端，进程保持睡眠状态直到调用信息的到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，最后，客户端调用过程接收答复信息，获得进程结果，然后调用执行继续进行。
下面通过模拟实现一个简单的RPC，核心部分如下
RPC客户端动态代理：
package cn.ith.rpc;
import java.lang.reflect.Proxy;
//RPC客户端动态代理
public class RpcProxy<T> {
public T getProxy(String host, int port, Class interfaceClass) {
return (T) Proxy.newProxyInstance(getClass().getClassLoader(),
new Class[]{interfaceClass},
new RemoteInvocationHandler(host, port, interfaceClass));
}
}客户端动态代理的具体实现：
package cn.ith.rpc;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.net.Socket;
//客户端动态代理的具体实现
public class RemoteInvocationHandler implements InvocationHandler {
private String host; //远程调用的主机ip
private int port; //远程调用的端口号
private Class interfaceClass; //远程调用的类
public RemoteInvocationHandler(String host, int port, Class interfaceClass) {
this.host = host;
this.port = port;
this.interfaceClass = interfaceClass;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//建立socket连接
Socket socket = new Socket(host, port);
//封装客户端请求消息
RpcMessage rpcMessage = new RpcMessage();
//反射获取类名、方法名、方法的参数类型
rpcMessage.setClassName(interfaceClass.getName());
rpcMessage.setMethodName(method.getName());
rpcMessage.setParams(args);
rpcMessage.setTypes(method.getParameterTypes());
//获取套输出接字流，发送消息给服务端
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(rpcMessage);
oos.flush();
//获取套接字输出流，读取服务端返回结果
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Object result = ois.readObject();
return result;
}
}用于封装远程调用的类名、方法名、请求参数、请求参数的类型的类：
package cn.ith.rpc;
import java.io.Serializable;
//用于封装远程调用的类名、方法名、请求参数、请求参数的类型的类
public class RpcMessage implements Serializable {
private String className; //请求的类名
private String methodName; //请求的方法名
private Object[] params; //请求参数
private Class[] types; //请求参数的类型
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 Object[] getParams() {
return params;
}
public void setParams(Object[] params) {
this.params = params;
}
public Class[] getTypes() {
return types;
}
public void setTypes(Class[] types) {
this.types = types;
}
}Rpc服务端实现：
package cn.ith.rpc;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//Rpc服务端实现
public class RpcServer {
/**
* 开启服务
* @param port
*/
public void start(int port) {
//指定一个线程池
ExecutorService threadPool = Executors.newCachedThreadPool();
try {
//开启一个socket
ServerSocket serverSocket = new ServerSocket(port);
while(true) {
//监听客户端请求
Socket socket = serverSocket.accept();
//拿到一个线程处理客户端请求
threadPool.execute(new ProcessHandler(socket));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}实现服务端的具体逻辑：
package cn.ith.rpc;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.Socket;
//实现服务端的具体逻辑
public class ProcessHandler implements Runnable {
private Socket socket;
public ProcessHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//处理服务端核心逻辑
//1.接收到消息
//2.反射调用本都方法
//3.返回结果
try {
//获取套接字输入流，从输入流中读取数据（接受客户端消息）
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
RpcMessage rpcMessage = (RpcMessage)ois.readObject();
//获取接口名
String clazzName = rpcMessage.getClassName();
Class clazz = null; //接口对应的实现类
if(Registry.map.containsKey(clazzName)) {
clazz = Registry.map.get(clazzName);
}
Method method = null;
Object result = null;
try {
method = clazz.getMethod(rpcMessage.getMethodName(), rpcMessage.getTypes());
result = method.invoke(clazz.newInstance(), rpcMessage.getParams());
} catch (Exception e) {
e.printStackTrace();
}
//返回结果
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(result);
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}服务端程序：
public class Server {
public static void main(String[] args) {
Registry.map.put(ProductService.class.getName(), ProductServiceImpl.class);
new RpcServer().start(8888);
}
}客户端程序：
import cn.ith.api.service.ProductService;
import cn.ith.rpc.RpcProxy;
public class Client {
public static void main(String[] args) {
RpcProxy proxy = new RpcProxy();
ProductService productService = (ProductService)proxy.getProxy("localhost", 8888, ProductService.class);
System.out.println(productService.getById(10L));
}
}运行服务端和客户端程序，结果如下：
源码：
链接：https://pan.baidu.com/s/1D1iuJxlhyvRtMmRr4YszHw
提取码：ot4f
SPI
SPI（Service Provider Interface），是一种服务发现机制。SPI的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态获得到接口的实现类。
也就是说SPI就是为了拿到接口的实现类。
JDK SPI
Java对SPI的实现是通过ServiceLoader类，读取配置文件，得到实现类，并反射实例化类对象。
下面通过一个例子来了解ServiceLoader
接口Shape：
package cn.ith.spi.service;
public interface Shape {
public void draw();
}实现类Circle ：
package cn.ith.spi.service.impl;
import cn.ith.spi.service.Shape;
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("draw a circle");
}
}实现类Rectangle ：
package cn.ith.spi.service.impl;
import cn.ith.spi.service.Shape;
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("draw a rectangle");
}
}有ServiceLoader加载读取配置文件，ServiceLoader部分源码如下，"META-INF/services/"指定配置文件根路径：
配置文件名为接口的权限定名，内容为接口实现类的全限定名：
cn.ith.spi.service.impl.Circle
cn.ith.spi.service.impl.Rectangle使用ServiceLoader：
public class JavaSPI {
public static void main(String[] args) {
ServiceLoader<Shape> serviceLoader = ServiceLoader.load(Shape.class);
for (Shape shape : serviceLoader) {
shape.draw();
}
}
}结果：
Dubbo SPI
ServiceLoader有一个缺陷就是所有配置的实现类都会被加载并实例化。Dubbo对SPI的实现（ExtensionLoader类）就避免了这种缺陷。
下面通过一个例子来学习Dubbo对SPI的实现。
在上面的例子上进行修改
加入依赖：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>dubbo</artifactId>
<version>2.6.2</version>
</dependency>Shape类加上@SPI注解：
package cn.ith.spi.service;
import com.alibaba.dubbo.common.extension.SPI;
//使用SPI注解，并指定默认实现类
@SPI("circle")
public interface Shape {
public void draw();
}在resources\META-INF\dubbo目录下创建文件夹cn.ith.spi.service.Shape，内容如下：
circle = cn.ith.spi.service.impl.Circle
rectangle = cn.ith.spi.service.impl.Rectanglemain方法：
public static void main(String[] args) {
ExtensionLoader<Shape> extensionLoader = ExtensionLoader.getExtensionLoader(Shape.class);
//获取默认的接口实现类对象
Shape shape = extensionLoader.getDefaultExtension();
shape.draw();
//获取指定的接口实现类对象
shape = extensionLoader.getExtension("rectangle");
shape.draw();
}
链接：https://pan.baidu.com/s/1RcFgqp9Mm3xrIarO1N9D6A
提取码：fxcj
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
