分布式架构设计（一） --- 面向服务的体系架构 SOA

1.1 基于TCP协议的RPC

1.1.1 RPC名词解释

　　RPC的全称是Remote Process Call，即远程过程调用，RPC的实现包括客户端和服务端，即服务调用方和服务提供方。服务调用方发送RPC请求到服务提供方，服务提供方根据请求的参数执行请求方法，并将结果返回给服务调用方，一次RPC调用完成。

1.1.2 对象的序列化

　　在网络上传输的数据，无论何种类型，最终都需要转化为二进制流。在面向对象的程序设计中，客户端将对象转化为二进制流发送给服务端，服务端接收数据后将二进制流转化为对象，java中将这两种转化方式称为对象的序列化和反序列化。下面介绍java内置的序列化方式和基于java的Hessian序列化方式：

java内置的序列化和反序列化关键代码：

　　

         //序列化操作
         Person person = new Person();
         ByteArrayOutputStream os = new ByteArrayOutputStream();
         ObjectOutputStream out = new ObjectOutputStream(os);
         out.writeObject(person);
         byte[] byteArray = os.toByteArray();

         //反序列化操作
         ByteArrayInputStream is = new ByteArrayInputStream(byteArray);
         ObjectInputStream in = new ObjectInputStream(is);
         Person newPerson = new Person();
         newPerson = (Person) in.readObject();

基于java的Hessian序列化和反序列化关键代码：

         //序列化操作
         ByteArrayOutputStream osH = new ByteArrayOutputStream();
         HessianOutput outH = new HessianOutput(osH);
         outH.writeObject(person);
         byte[] byteArrayH = osH.toByteArray();

         //反序列化操作
         ByteArrayInputStream isH = new ByteArrayInputStream(byteArrayH);
         HessianInput inH = new HessianInput(isH);
         newPerson = (Person) inH.readObject();

1.1.3 基于TCP协议实现RPC

我们利用java的SocketAPI实现一个简单的RPC调用，服务的接口和实现比较简单，根据传入的参数来判断返回"hello" or "bye bye"。

 public interface SayHelloService {

     public String sayHello(String arg);
 }

 public class SayHelloServiceImpl implements SayHelloService {

     public String sayHello(String arg) {
         return "hello".equals(arg) ? "hello" : "bye bye";
     }

 }

服务消费者Consumer类：

 /**
  * 基于TCP协议实现RPC -- 服务消费者
  * @author admin
  *
  */
 public class Consumer {

     public static void main(String[] args) throws Exception {
         //接口名称
         String interfaceName = SayHelloService.class.getName();
         //需要执行远程的方法
         Method method = SayHelloService.class.getMethod("sayHello", String.class);
         //传递到远程的参数
         Object [] arguments = {"hello"};
         Socket socket = new Socket("127.0.0.1", 1234);
         //将方法名和参数传递到远端
         ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
         out.writeUTF(interfaceName);//接口名称
         out.writeUTF(method.getName());//方法名称
         out.writeObject(method.getParameterTypes());//方法参数类型
         out.writeObject(arguments);//传递的参数
         System.out.println("发送信息到服务端，发送的信息为:" + arguments[0]);
         //从远端读取返回结果
         ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
         String result = (String) in.readObject();
         System.out.println("服务返回的结果为：" + result);
     }
 }

服务提供者Provider类：

 /**
  * 基于TCP协议实现RPC -- 服务提供者
  * @author admin
  *
  */
 public class Provider {

     public static void main(String[] args) throws Exception {
         ServerSocket server = new ServerSocket(1234);
         Map<Object, Object> services = new HashMap<Object, Object>();
         services.put(SayHelloService.class.getName(), new SayHelloServiceImpl());
         while(true) {
             System.out.println("服务提供者启动，等待客户端调用…………");
             Socket socket = server.accept();
             //读取服务信息
             ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
             String interfaceName = in.readUTF();
             String methodName = in.readUTF();
             Class<?>[] parameterTypes = (Class<?>[]) in.readObject();
             Object [] arguments = (Object[]) in.readObject();
             System.out.println("客户端调用服务端接口" + interfaceName + "的" + methodName + "方法");
             //执行调用
             Class serviceClass = Class.forName(interfaceName);//得到接口的class
             Object service = services.get(interfaceName);//取得服务实现的对象
             Method method = serviceClass.getMethod(methodName, parameterTypes);//获得要调用的方法
             Object result = method.invoke(service, arguments);
             ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
             out.writeObject(result);
             System.out.println("服务端返回结果为：" + result);
         }
     }
 }

在真实的生产环境中往往是多个客户端同时请求服务端，服务端则需要同时接收和处理多个客户端请求消息，涉及并发处理、服务路由、负载均衡等现实问题，以上代码显然不能完成。

1.2 基于HTTP协议的RPC

1.2.1 HTTP协议栈

HTTP的全称是HyperText Transfer Protocol，即超文本传输协议，当今普遍采用的版本是HTTP1.1。HTTP协议属于应用层协议，它构建在TCP和IP协议之上，处于TCP/IP架构的顶端，为了更好的理解HTTP协议，我们基于java的SocketAPI设计一个简单的应用层通信协议，来窥探协议实现的一些过程与细节。

客户端向服务端发送一条命令，服务端接收到命令后，会判断命令是否为"HELLO"，若是则返回客户端"hello!",否则返回客户端"bye bye"。

 /**
  * 协议请求
  *
  * @author admin
  *
  */
 public class Request {

     /**
      * 协议编码 0：GBK；1：UTF-8
      */
     private byte encode;
     /**
      * 命令
      */
     private String command;
     /**
      * 命令长度
      */
     private int commandLength;

     public byte getEncode() {
         return encode;
     }

     public void setEncode(byte encode) {
         this.encode = encode;
     }

     public String getCommand() {
         return command;
     }

     public void setCommand(String command) {
         this.command = command;
     }

     public int getCommandLength() {
         return commandLength;
     }

     public void setCommandLength(int commandLength) {
         this.commandLength = commandLength;
     }

 }

 /**
  * 协议响应
  *
  * @author admin
  *
  */
 public class Response {
     /**
      * 编码
      */
     private byte encode;
     /**
      * 响应
      */
     private String response;
     /**
      * 响应长度
      */
     private int responseLength;

     public byte getEncode() {
         return encode;
     }

     public void setEncode(byte encode) {
         this.encode = encode;
     }

     public String getResponse() {
         return response;
     }

     public void setResponse(String response) {
         this.response = response;
     }

     public int getResponseLength() {
         return responseLength;
     }

     public void setResponseLength(int responseLength) {
         this.responseLength = responseLength;
     }

     @Override
     public String toString() {
         return "Response [encode=" + encode + ", response=" + response + ", responseLength=" + responseLength + "]";
     }

 }

客户端发送以及服务端响应处理代码：

 /**
  * 服务端
  * @author admin
  *
  */
 public class Server {

     public static void main(String[] args) throws Exception {
         ServerSocket server = new ServerSocket(1234);
         while(true) {
             Socket client = server.accept();
             //读取请求数据
             Request request = ProtocolUtil.readRequest(client.getInputStream());
             //封装响应数据
             Response response = new Response();
             response.setEncode(Encode.UTF8.getValue());
             response.setResponse(request.getCommand().equals("HELLO") ? "hello!" : "bye bye");
             response.setResponseLength(response.getResponse().length());
             //响应到客户端
             ProtocolUtil.writeResponse(client.getOutputStream(), response);
         }
     }
 }

 /**
  * 客户端
  * @author admin
  *
  */
 public class Client {

     public static void main(String[] args) throws Exception {
         //组装请求数据
         Request request = new Request();
         request.setCommand("HELLO");
         request.setCommandLength(request.getCommand().length());
         request.setEncode(Encode.UTF8.getValue());
         Socket client = new Socket("127.0.0.1", 1234);
         //发送请求
         ProtocolUtil.writeRequest(client.getOutputStream(), request);
         //读取相应
         Response response = ProtocolUtil.readResponse(client.getInputStream());
         System.out.println(response);
     }
 }

ProtocolUtil 类：

 public class ProtocolUtil {

     public static void writeRequest(OutputStream out, Request request) {
         try {
             out.write(request.getEncode());
             //write一个int值会截取其低8位传输，丢弃其高24位，因此需要将基本类型转化为字节流
             //java采用Big Endian字节序，而所有的网络协议也都是以Big Endian字节序来进行传输，所以再进行数据的传输和接收时，需要先将数据转化成Big Endian字节序
             //out.write(request.getCommandLength());
             out.write(int2ByteArray(request.getCommandLength()));
             out.write(Encode.GBK.getValue() == request.getEncode() ? request.getCommand().getBytes("GBK") : request.getCommand().getBytes("UTF8"));
             out.flush();
         } catch (Exception e) {
             System.err.println(e.getMessage());
         }
     }

     /**
      * 将响应输出到客户端
      * @param os
      * @param response
      */
     public static void writeResponse(OutputStream out, Response response) {
         try {
             out.write(response.getEncode());
             out.write(int2ByteArray(response.getResponseLength()));
             out.write(Encode.GBK.getValue() == response.getEncode() ? response.getResponse().getBytes("GBK") : response.getResponse().getBytes("UTF8"));
             out.flush();
         } catch (Exception e) {
             System.err.println(e.getMessage());
         }
     }

     public static Request readRequest(InputStream is) {
         Request request = new Request();
         try {
             //读取编码
             byte [] encodeByte = new byte[1];
             is.read(encodeByte);
             byte encode = encodeByte[0];
             //读取命令长度
             byte [] commandLengthByte = new byte[4];//缓冲区
             is.read(commandLengthByte);
             int commandLength = byte2Int(commandLengthByte);
             //读取命令
             byte [] commandByte = new byte[commandLength];
             is.read(commandByte);
             String command = Encode.GBK.getValue() == encode ? new String(commandByte, "GBK") : new String(commandByte, "UTF8");
             //组装请求返回
             request.setEncode(encode);
             request.setCommand(command);
             request.setCommandLength(commandLength);
         } catch (Exception e) {
             System.err.println(e.getMessage());
         }
         return request;
     }

     public static Response readResponse(InputStream is) {
         Response response = new Response();
         try {
             byte [] encodeByte = new byte[1];
             is.read(encodeByte);
             byte encode = encodeByte[0];
             byte [] responseLengthByte = new byte[4];
             is.read(responseLengthByte);
             int commandLength = byte2Int(responseLengthByte);
             byte [] responseByte = new byte[commandLength];
             is.read(responseByte);
             String resContent = Encode.GBK.getValue() == encode ? new String(responseByte, "GBK") : new String(responseByte, "UTF8");
             response.setEncode(encode);
             response.setResponse(resContent);
             response.setResponseLength(commandLength);
         } catch (Exception e) {
             System.err.println(e.getMessage());
         }
         return response;
     }

     public static int byte2Int(byte [] bytes) {
         int num = bytes[3] & 0xFF;
         num |= ((bytes[2] << 8) & 0xFF00);
         num |= ((bytes[1] << 16) & 0xFF0000);
         num |= ((bytes[0] << 24) & 0xFF000000);
         return num;
     }

     public static byte[] int2ByteArray(int i) {
         byte [] result = new byte[4];
         result[0] = (byte) ((i >> 24) & 0xFF);
         result[1] = (byte) ((i >> 16) & 0xFF);
         result[2] = (byte) ((i >> 8) & 0xFF);
         result[3] = (byte) (i & 0xFF);
         return result;
     }

 }

1.2.2 HTTP请求与响应

下图是HTTP请求与响应的过程步骤，在此不详细赘述。

1.2.3 通过HttpClient发送HTTP请求

HttpClient对HTTP协议通信的过程进行了封装，下面是简单的通过HttpClient发送HTTP GET请求，并获取服务端响应的代码：

 　　　　  //url前加上http协议头，标明该请求为http请求
         String url = "https://www.baidu.com";
         //组装请求
         HttpClient httpClient = new DefaultHttpClient();
         HttpGet httpGet = new HttpGet(url);
         //接收响应
         HttpResponse response = httpClient.execute(httpGet);
         HttpEntity entity = response.getEntity();
         byte[] byteArray = EntityUtils.toByteArray(entity);
         String result = new String(byteArray, "utf8");
         System.out.println(result);

1.2.4 使用HTTP协议的优势

　　随着请求规模的扩展，基于TCP协议的RPC的实现，需要考虑多线程并发、锁、I/O等复杂的底层细节，在大流量高并发的压力下，任何一个小的错误都可能被无限放大，最终导致程序宕机。而对于基于HTTP协议的实现来说，很多成熟的开源web容易已经帮其处理好了这些事情，如Apache，Tomcat，Jboss等，开发人员可将更多的精力集中在业务实现上，而非处理底层细节。