RPC实现原理（HSF、dubbo） 从头开始（一）
前言
阔别了很久博客园，虽然看了以前写的很多东西感觉好幼稚，但是还是觉得应该把一些自己觉得有用的东西和大家分享。废话不多说，现在开始进入正题。
之前的六年工作经验，呆过了一些大公司，每个在大公司呆过的人应该知道，在一个大型应用中不断的增加业务和功能，还有基于性能的考虑，使得很多基础服务必须进行模块化，从而让各子系统方便使用而不是每个系统重新再实现一套，也可以使可能成为瓶颈的基础功能可以单独进行扩展，比如（以电商系统举例）用户信息管理、交易管理中心、商品管理中心等等。 在rpc发展最初，服务进行模块块以后，各个子系统、模块实现的技术五花八门，如：hessian、WebService、Socket、http等进行互相调用，各个子系统之间的交互方式和方法不统一，使得各系统间很难很好的整合。并且这些方式还涉及超时、加密解密、参数的传递等各种问题。 在这种情况下，hsf、dubbo这种高性能rpc中间件出现了。 现在我就已最简单的方式从头开始讲起其中的原理。
我将分为一个系列为大家进行解剖
一、RPC实现原理（HSF、dubbo） 从头开始（一）
二、RPC实现原理（HSF、dubbo）发布一个服务与订阅一个服务（三）
三、RPC实现原理（HSF、dubbo）zookeeper进行集群配置管理（二）
四、RPC实现原理（HSF、dubbo）netty替换java socket（四）
五、待补充
NO.1 TCP传输协议
为什么选择TCP作为传输协议？HTTP在TCP的上一层，位于应用层，TCP位于网络层，以越往底层越快的原理，我就不过多解释为什么选择tcp作为传输协议了。 那么在项目中我们怎么使用tcp进行调用呢？直接上个例子代码：
socket服务端：
import java.net.*; import java.io.*; /** * socket编程之：简单socket server * * @author chengwei.lcw 2016-11-27 */ public class SocketServer { private ServerSocket serverSocket; private Socket socket; private BufferedReader in; private PrintWriter out; public SocketServer() { try { serverSocket = new ServerSocket(9999); while (true) { // 此处会阻塞，后面会讲到nio的作用 socket = serverSocket.accept(); in = new BufferedReader(new InputStreamReader( socket.getInputStream())); out = new PrintWriter(socket.getOutputStream(), true); String line = in.readLine(); // 打印出来看看结果 System.out.println("line:" + line); // 返回给client端，通知我已收到数据 out.println("you input is :" + line); out.close(); in.close(); socket.close(); } } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { new SocketServer(); } }
scoket客户端：
import java.io.*; import java.net.*; /** * socket编程之：简单socket client * * @author chengwei.lcw 2016-11-27 */ public class SocketClient { private Socket socket; private BufferedReader in; private PrintWriter out; public SocketClient() { try { socket = new Socket("127.0.0.1", 9999); in = new BufferedReader(new InputStreamReader( socket.getInputStream())); out = new PrintWriter(socket.getOutputStream(), true); // 向服务端写数据 BufferedReader line = new BufferedReader(new InputStreamReader( System.in)); out.println(line.readLine()); line.close(); // 打印出来服务端发回来的回执 System.out.println(in.readLine()); in.close(); out.close(); socket.close(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { new SocketClient(); } }
先启动server，再启动client，输入参数，回车，两者第一次会话完成。
小结总结：
目前例子中我们使用了标准io socket，这里的很多时候会阻塞，如accept()、read()时都会阻塞。测试的时候可以让客户端睡眠几秒，在这期间启动第二个客户端，这个时候第一个客户端未完成前，第二个客户端是被阻塞在accept()中的。 这种情况可以给每个客户端都单独分配一个线程，但是这样创建过多的线程，可能会严重影响服务器的性能。 第二种解决方案就是使用NIO 非阻塞的通信方式，jdk1.4之后已经引入了这个功能，这样可以使得服务器只要启动一个线程就能处理所有的客户端socket请求。netty就是基于NIO的高性能框架，相比jdk nio做了很多改进，修复了一些缺陷。 (这里不对netty与jdk nio做过多赘述，这不在我们讨论原理细节里，如果大家对这方面有兴趣，我会单独写篇随笔进行深度讲解)
NO.2 序列化方式
在真正的项目中，很多时候我们传的都是自己定义的类。在远程通讯中，类的传输我们需要对类进行序列化和反序列化。序列化的方式有多种，如二进制、xml、soap。我们就以用的最多的二进制进行举例：
socket服务端：
import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.net.ServerSocket; import java.net.Socket; /** * socket编程之：传输对象server * * @author chengwei.lcw 2016-11-27 */ public class SocketObjectSever { private ServerSocket serverSocket; private ObjectInputStream in; private ObjectOutputStream out; public SocketObjectSever() { try { serverSocket = new ServerSocket(9999); while (true) { // 此处会阻塞，后面会讲到nio的作用 Socket socket = serverSocket.accept(); in = new ObjectInputStream(socket.getInputStream()); out = new ObjectOutputStream(socket.getOutputStream()); // 接收server端传来的数据，并转为Student Student student = (Student) in.readObject(); // 重写了toString()方法，打印出来看看 System.out.println("Server: " + student); // 返回给client端，通知我已收到数据 out.writeObject("yes client, I receive"); out.flush(); } } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } public static void main(String[] args) { new SocketObjectSever(); } }
socket客户端：
import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.net.Socket; import java.net.UnknownHostException; /** * socket编程之：传输对象client * * @author chengwei.lcw 2016-11-27 */ public class SocketObjectClient { private Socket socket; private ObjectInputStream in; private ObjectOutputStream out; public SocketObjectClient() { try { socket = new Socket("127.0.0.1",9999); out = new ObjectOutputStream(socket.getOutputStream()); in = new ObjectInputStream(socket.getInputStream()); /* * 建一个student对象，用于传输 */ Student s = new Student("chengwei.lcw", 28); // 把对象写到管道中，client端进行接收 out.writeObject(s); out.flush(); String receive = (String) in.readObject(); System.out.println("Client Receive :"+receive); in.close(); out.close(); socket.close(); } catch (UnknownHostException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } public static void main(String[] args) { new SocketObjectClient(); } }
另外定义一个要传输的类：
import java.io.Serializable; /** * socket编程之：要进行传输的类，需要继承Serializable接口 * * @author chengwei.lcw 2016-11-27 * */ public class Student implements Serializable { private static final long serialVersionUID = 1L; private String name; private int age; public Student(String name, int age) { this.name = name; this.age = age; } public String toString() { return "name=" + this.name + ", age=" + this.age; } }
依然先启动server，再启动client，server端控制台输出：
Server: name=chengwei.lcw, age=28
这样为止，我们的socket可以传输对象了。
这里我们使用的序列化方式为java直接进行序列化，而hessian序列化比Java序列化高效很多，生成的字节流也要短很多，因为hessian在序列化时会把字节流进行压缩。在后面的升级版中我会使用hessian序列化的方式进行序列化。
公司里还有事，而且我不知道这些是不是各位朋友想看到的内容，忙完今天我会继续进行补充。 哪里有讲的不对的希望大家来矫正。
