什么是微服务？微服务之间是如何独立通讯的？

什么是微服务

  • 微服务架构是一个分布式系统，按照业务进行划分成为不同的服务单元，解决单体系统性能等不足。
  • 微服务是一种架构风格，一个大型软件应用由多个服务单元组成。系统中的服务单元可以单独部署，各个服务单元之间是松耦合的。

微服务概念起源：Microservices

微服务之间是如何独立通讯的

同步

REST HTTP 协议

REST 请求在微服务中是最为常用的一种通讯方式，它依赖于 HTTP\HTTPS 协议。RESTFUL 的特点是：

  1. 每一个 URI 代表 1 种资源
  2. 客户端使用 GET、POST、PUT、DELETE 4 个表示操作方式的动词对服务端资源进行操作：GET 用来获取资源，POST 用来新建资源（也可以用于更新资源），PUT 用来更新资源，DELETE 用来删除资源
  3. 通过操作资源的表现形式来操作资源
  4. 资源的表现形式是 XML 或者 HTML
  5. 客户端与服务端之间的交互在请求之间是无状态的,从客户端到服务端的每个请求都必须包含理解请求所必需的信息

举个例子，有一个服务方提供了如下接口：

  1. @RestController
  2. @RequestMapping("/communication")
  3. public class RestControllerDemo {
  4.     @GetMapping("/hello")
  5.     public String s() {
  6.         return "hello";
  7.     }
  8. }

另外一个服务需要去调用该接口，调用方只需要根据 API 文档发送请求即可获取返回结果。

  1. @RestController
  2. @RequestMapping("/demo")
  3. public class RestDemo{
  4.     @Autowired
  5.     RestTemplate restTemplate;
  7.     @GetMapping("/hello2")
  8.     public String s2() {
  9.         String forObject = restTemplate.getForObject("http://localhost:9013/communication/hello", String.class);
  10.         return forObject;
  11.     }
  12. }

通过这样的方式可以实现服务之间的通讯。

RPC TCP 协议

RPC(Remote Procedure Call)远程过程调用，简单的理解是一个节点请求另一个节点提供的服务。它的工作流程是这样的：

  1. 执行客户端调用语句，传送参数
  2. 调用本地系统发送网络消息
  3. 消息传送到远程主机
  4. 服务器得到消息并取得参数
  5. 根据调用请求以及参数执行远程过程（服务）
  6. 执行过程完毕，将结果返回服务器句柄
  7. 服务器句柄返回结果，调用远程主机的系统网络服务发送结果
  8. 消息传回本地主机
  9. 客户端句柄由本地主机的网络服务接收消息
  10. 客户端接收到调用语句返回的结果数据

举个例子。

首先需要一个服务端：

  1. import java.io.IOException;
  2. import java.io.ObjectInputStream;
  3. import java.io.ObjectOutputStream;
  4. import java.lang.reflect.Method;
  5. import java.net.InetSocketAddress;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  8. import java.util.concurrent.ConcurrentHashMap;
  9. import java.util.concurrent.ExecutorService;
  10. import java.util.concurrent.Executors;
  12. /**
  13.  * RPC 服务端用来注册远程方法的接口和实现类
  14.  */
  15. public class RPCServer {
  16.     private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
  18.     private static final ConcurrentHashMap<String, Class> serviceRegister = new ConcurrentHashMap<>();
  20.     /**
  21.      * 注册方法
  22.      * @param service
  23.      * @param impl
  24.      */
  25.     public void register(Class service, Class impl) {
  26.         serviceRegister.put(service.getSimpleName(), impl);
  27.     }
  29.     /**
  30.      * 启动方法
  31.      * @param port
  32.      */
  33.     public void start(int port) {
  34.         ServerSocket socket = null;
  35.         try {
  36.             socket = new ServerSocket();
  37.             socket.bind(new InetSocketAddress(port));
  38.             System.out.println("服务启动");
  39.             System.out.println(serviceRegister);
  40.             while (true) {
  41.                 executor.execute(new Task(socket.accept()));
  42.             }
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.         } finally {
  46.             if (socket != null) {
  47.                 try {
  48.                     socket.close();
  49.                 } catch (IOException e) {
  50.                     e.printStackTrace();
  51.                 }
  52.             }
  53.         }
  54.     }
  56.     private static class Task implements Runnable {
  57.         Socket client = null;
  59.         public Task(Socket client) {
  60.             this.client = client;
  61.         }
  63.         @Override
  64.         public void run() {
  65.             ObjectInputStream input = null;
  66.             ObjectOutputStream output = null;
  67.             try {
  68.                 input = new ObjectInputStream(client.getInputStream());
  69.                 // 按照顺序读取对方写过来的内容
  70.                 String serviceName = input.readUTF();
  71.                 String methodName = input.readUTF();
  72.                 Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
  73.                 Object[] arguments = (Object[]) input.readObject();
  74.                 Class serviceClass = serviceRegister.get(serviceName);
  75.                 if (serviceClass == null) {
  76.                     throw new ClassNotFoundException(serviceName + " 没有找到!");
  77.                 }
  78.                 Method method = serviceClass.getMethod(methodName, parameterTypes);
  79.                 Object result = method.invoke(serviceClass.newInstance(), arguments);
  81.                 output = new ObjectOutputStream(client.getOutputStream());
  82.                 output.writeObject(result);
  83.             } catch (Exception e) {
  84.                 e.printStackTrace();
  86.             } finally {
  87.                 try {
  88.                     // 这里就不写 output!=null才关闭这个逻辑了
  89.                     output.close();
  90.                     input.close();
  91.                     client.close();
  92.                 } catch (IOException e) {
  93.                     e.printStackTrace();
  94.                 }
  96.             }
  97.         }
  98.     }
  100. }

其次需要一个客户端：

  1. import java.io.ObjectInputStream;
  2. import java.io.ObjectOutputStream;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  6. import java.net.InetSocketAddress;
  7. import java.net.Socket;
  9. /**
  10.  * RPC 客户端
  11.  */
  12. public class RPCclient<T> {
  13.     /**
  14.      * 通过动态代理将参数发送过去到 RPCServer ,RPCserver 返回结果这个方法处理成为正确的实体
  15.      */
  16.     public static <T> T getRemoteProxyObj(final Class<T> service, final InetSocketAddress addr) {
  18.         return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service}, new InvocationHandler() {
  19.             @Override
  20.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  22.                 Socket socket = null;
  23.                 ObjectOutputStream out = null;
  24.                 ObjectInputStream input = null;
  25.                 try {
  26.                     socket = new Socket();
  27.                     socket.connect(addr);
  29.                     // 将实体类,参数,发送给远程调用方
  30.                     out = new ObjectOutputStream(socket.getOutputStream());
  31.                     out.writeUTF(service.getSimpleName());
  32.                     out.writeUTF(method.getName());
  33.                     out.writeObject(method.getParameterTypes());
  34.                     out.writeObject(args);
  36.                     input = new ObjectInputStream(socket.getInputStream());
  37.                     return input.readObject();
  38.                 } catch (Exception e) {
  39.                     e.printStackTrace();
  40.                 } finally {
  41.                     out.close();
  42.                     input.close();
  43.                     socket.close();
  44.                 }
  45.                 return null;
  46.             }
  47.         });
  49.     }
  51. }

再来一个测试的远程方法。

  1. public interface Tinterface {
  2.     String send(String msg);
  3. }
  5. public class TinterfaceImpl implements Tinterface {
  6.     @Override
  7.     public String send(String msg) {
  8.         return "send message " + msg;
  9.     }
  10. }

测试代码如下：

  1. import java.net.InetSocketAddress;
  4. public class RunTest {
  5.     public static void main(String[] args) {
  6.         new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 RPCServer rpcServer = new RPCServer();
  10.                 rpcServer.register(Tinterface.class, TinterfaceImpl.class);
  11.                 rpcServer.start(10000);
  12.             }
  13.         }).start();
  14.         Tinterface tinterface = RPCclient.getRemoteProxyObj(Tinterface.class, new InetSocketAddress("localhost", 10000));
  15.         System.out.println(tinterface.send("rpc 测试用例"));
  17.     }
  18. }

输出 send message rpc 测试用例 。

异步

消息中间件

常见的消息中间件有 Kafka、ActiveMQ、RabbitMQ、RocketMQ ，常见的协议有 AMQP、MQTTP、STOMP、XMPP。这里不对消息队列进行拓展了，具体如何使用还是请移步官网。