RPC学习笔记

1、Remote Procedure Call

RPC的主要目标是让构建分布式更容易，在提供强大的远程调用能力时不损失本地调用的语义简洁性。为实现该目标，RPC框架需要提供一种透明的调用机制，让使用者不必显示的区别本地调用和远程调用。
RPC不是一个协议或者方法，它只是一个概念。是一个统称，重点在于方法调用（不支持对象的概念），具体实现甚至可以用RMI RestFul等去实现，但一般不用，因为RMI不能跨语言，而RestFul效率太低。
RPC多用于服务器集群之间的通信
从单机到分布式->分布式通信->最基本的东西:二进制数据传输
动态代理是RPC的核心之一
RPC和序列化是分不开的，因此产生了很多序列化框架
RPC不仅可以选序列化框架，网络协议也是可以选择的

1.1 现在有哪些RPC框架？

Dubbo：国内最早开源的 RPC 框架，由阿里巴巴公司开发并于 2011 年末对外开源，仅支持 Java 语言。
Motan：微博内部使用的 RPC 框架，于 2016 年对外开源，仅支持 Java 语言。
Tars：腾讯内部使用的 RPC 框架，于 2017 年对外开源，仅支持 C++ 语言。
SpringCloud：国外 Pivotal 公司 2014 年对外开源的 RPC 框架，提供了丰富的生态组件。
gRPC：Google 于 2015 年对外开源的跨语言 RPC 框架，支持多种语言。
Thrift：最初是由 Facebook 开发的内部系统跨语言的 RPC 框架，2007 年贡献给了 Apache 基金，成为Apache 开源项目之一，支持多种语言。

1.2 RPC具体步骤？

服务消费者（client客户端）通过本地调用的方式调用服务。
客户端存根（client stub）接收到请求后负责将方法、入参等信息序列化（组装）成能够进行网络传输的消息
体。
客户端存根（client stub）找到远程的服务地址，并且将消息通过网络发送给服务端。
服务端存根（server stub）收到消息后进行解码（反序列化操作）。
服务端存根（server stub）根据解码结果调用本地的服务进行相关处理。
本地服务执行具体业务逻辑并将处理结果返回给服务端存根（server stub）。
服务端存根（server stub）将返回结果重新打包成消息（序列化）并通过网络发送至消费方。
客户端存根（client stub）接收到消息，并进行解码（反序列化）。
服务消费方得到最终结果。

2、RPC涉及的技术？

动态代理
生成Client Stub和Server Stub的时候需要用到java动态代理技术
序列化
在网络中，所有的数据都会被转换成字节进行传送，需要对这些参数进行序列化和反序列化操作，目前最主流高效的开源序列化框架有:Kryo、FastJson、Hessian、Protobuf等
NIO通信
java提供了NIO的解决方案，可以采用Netty或者mina框架来解决NIO的数据传输问题。开源的RPC框架Dubbo就是采用NIO通信，集成支持netty、mina、grizzly
服务注册中心
通过服务注册中心，让客户端的连接调用服务端所发布的服务。主流的注册中心组件有:Redis、Zookeeper、Consul、ETcd。Dubbo采用的是Zookeeper提供的服务注册与发现功能。
负载均衡
在高并发的场景下，需要多个节点或集群来提升整体吞吐能力
健康检查
健康检查包括：客户端心跳和服务端主动探测两种方式

3、RPC序列化框架的选型

Hessian比JDK序列化快、而且序列化之后的长度更短。
java自带的序列化方式Serializable接口，只支持Java代码，效率很低且所占空间比较大
因此在设计RPC框架时，可以选用一些其他的序列化框架，如Hessian等

3.1 JDK Serializable

JDK Serializable是Java自带的序列化框架，我们只需要实现java.io.Serilizable或java.io.Externalizable接口，就可以使用java自带的序列化机制。
实现序列化接口只是表示该类能够被序列化或反序列化，还需要借助IO操作的ObjectInputStream和ObjectOutputStream对对象进行序列化和反序列化。
缺点：

只能支持Java语言，不能跨语言使用。
不好用，语法生硬
速度慢，序列化的字节数组长度比较长，所占空间大

3.2 FST序列化框架

FST是完全兼容JDK序列化框架，它在序列化速度上能达到JDK的10倍，序列化结果只有JDK的1/3
语法及其简洁
序列化之后的开销也比JDK少
缺点：

1.FST同样是针对Java开发的序列化框架，因此也不能跨语言使用

3.3 Kryo序列化框架

Kryo是一个快速有效的Java序列化框架，它依赖底层ASM库用于字节码的生成，因此有比较好的运行速度
Kryo的目标就是提供一个序列化速度快、结果体积小、API简单易用的序列化框架
Kryo支持自动深、浅拷贝，它是直接通过对象的深度拷贝，而不是对象->字节->对象的过程
语法比较简洁，API易用
缺点：

1.也是针对Java开发的，不具有跨语言特性

3.4 Protocol buffer

Protocol buffer是一种语言中立、平台无关、可扩展的序列化框架，Protocol buffer相较于前面几种序列化框架而言，它是需要预先定义Schema的。
ProtocolBuf设计之初的目标就是能够设计一款与语言无关的序列化框架，它目前支持Java/Python/C++/Go/C#等，通用性是很强的
Protocol需要使用IDL来定义Schema描述文件，定义完描述文件之后，可以直接使用protoc来生成序列化与反序列代码，因此，只需要简单编写描述文件，就可以使用protobuf了。
缺点:

反序列化性能比Kryo和FST差些

3.5 Thrift序列化框架

Thrift是由Facebook实现的一种高效的、支持多种语言的远程服务调用框架，即RPC，后来Facebook将Thrift开源到Apache。
Thrift是一个RPC框架，但是由于Thrift提供了多语言之间的RPC服务，所以很多时候被用于序列化中。
使用Thrift实现序列化主要分为3步:创建thrift IDL文件、编译生成Java代码、使用TSerializer和TDeserializer进行序列化和反序列化。
Thrift目前支持 C++、Java、Python、PHP、Ruby、 Erlang、Perl、Haskell、C#、Cocoa、JavaScript、Node.js、Smalltalk、OCaml、Delphi等语言
Thrift在序列化和反序列化的时间开销总和上和protobuf差不多，protobuf在序列化时间上更占优势，而Thrift在反序列化上有自己的优势

3.6 Hessian序列化框架

Hessian是caucho公司开发的轻量级RPC框架，它使用HTTP协议传输，使用Hessian二进制序列化。
Hessian支持跨语言、高效的二进制序列化协议，被经常用于序列化框架。
Hessian序列化使用简单

3.7 Avro序列化框架

Avro是一个数据序列化框架，它是Apache Hadoop下的一个子项目。
Avro在设计之初就用于支持数据密集型应用，很适合运城或本地大规模数据交换和存储
Avro通过Schema定义数据结构，目前支持Java、C、C++、C#、Python、PHP和Ruby语言
Avro对于动态语言无需生成代码，但对于Java这类静态语言，还是需要使用avro-tools.jar来编译生成Java代码。在Schema编写上，感觉相比Thrift、Protobuf更加复杂

3.8 开销的对比图

在这里插入图片描述

4/RPC框架的演进

①第一个版本
特点：通信代码与真正的业务代码混杂

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;

public class Client {
    public static void main(String[] args) throws Exception
    {
        Socket s = new Socket("127.0.0.1",8888);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();//开辟一块字节数组内存空间
        DataOutputStream dos = new DataOutputStream(baos);//操作数据的流
        dos.writeInt(123);//写死了
        //写数据
        s.getOutputStream().write(baos.toByteArray());//传输ID给服务器
        s.getOutputStream().flush();
        //读数据
        DataInputStream dis = new DataInputStream(s.getInputStream());
        int id = dis.readInt();
        String name = dis.readUTF();
        User user = new User(name,id);
        System.out.println(user);
        dos.close();
        s.close();

    }
}

--------------------------------------------------------------------------------
package com.demo.rpc01;

import com.demo.IUSerService;
import com.demo.User;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static boolean running = true;

    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(8888);
        while(running)
        {
            Socket s = ss.accept();//监听端口
            process(s);//处理请求
            s.close();//关闭连接
        }
        ss.close();
    }
    private static void process(Socket s) throws Exception
    {
        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();

        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        int id = dis.readInt();//读入ID
        IUSerService serService = new USerServiceImpl();
        User user = serService.getUSerById(id);

        dos.writeInt(user.getId());
        dos.writeUTF(user.getName());

        dos.flush();
    }
}
-----------------------------------------------------------------------------------
package com.demo.rpc01;

import com.demo.IUSerService;
import com.demo.User;

public class USerServiceImpl implements IUSerService {

    @Override
    public User getUSerById(Integer id) {
        return new User("Alice",id);
    }
}

②第二个版本
特点：将客户端通信代码封装成Stub，简化了客户端的使用

package com.demo.rpc02;

public class Client {
    public static void main(String[] args) throws Exception
    {
        Stub stub = new Stub();
        System.out.println(stub.getUserById(123));
    }
}

-----------------------------------------------------------------------------------
package com.demo.rpc02;

import com.demo.IUSerService;
import com.demo.User;
import com.demo.rpc01.USerServiceImpl;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static boolean running = true;
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(8888);
        while(running)
        {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
        ss.close();

    }

    private static void process(Socket s) throws Exception
    {
        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();

        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        int id = dis.readInt();
        IUSerService serService = new USerServiceImpl();
        User user = serService.getUSerById(id);

        dos.writeInt(user.getId());
        dos.writeUTF(user.getName());

        dos.flush();
    }
}
-----------------------------------------------------------------------------------
package com.demo.rpc02;

import com.demo.IUSerService;
import com.demo.User;

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;

public class Stub {
    public User getUserById(Integer id) throws Exception
    {
        Socket s = new Socket("127.0.0.1",8888);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        dos.writeInt(123);

        s.getOutputStream().write(baos.toByteArray());
        s.getOutputStream().flush();

        DataInputStream dis = new DataInputStream(s.getInputStream());
        int receivedId = dis.readInt();
        String name = dis.readUTF();
        User user = new User(name,id);

        dos.close();
        s.close();
        return user;
    }
}

③第三个版本
特点：运用动态代理，将客户端通信代码放在代理方法中,但这时接口是写死的，只能处理IUserService的业务请求

package com.demo.rpc03;

import com.demo.IUSerService;

public class Client {
    public static void main(String[] args) throws Exception
    {
        IUSerService stub = (IUSerService) Stub.getStub();
        System.out.println(stub.getUSerById(123));

    }
}
--------------------------------------------------------------------------------------------------
package com.demo.rpc03;

import com.demo.IUSerService;
import com.demo.User;
import com.demo.rpc01.USerServiceImpl;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static boolean running = true;
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(8888);
        while(running)
        {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
        ss.close();

    }

    private static void process(Socket s) throws Exception
    {
        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();

        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        int id = dis.readInt();
        IUSerService serService = new USerServiceImpl();
        User user = serService.getUSerById(id);

        dos.writeInt(user.getId());
        dos.writeUTF(user.getName());

        dos.flush();
    }
}
------------------------------------------------------------------------------------------
package com.demo.rpc03;

import com.demo.IUSerService;
import com.demo.User;

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;

public class Stub {
    public static Object getStub(){
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Socket s = new Socket("127.0.0.1",8888);

                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                DataOutputStream dos = new DataOutputStream(baos);
                dos.writeInt(123);

                s.getOutputStream().write(baos.toByteArray());
                s.getOutputStream().flush();

                DataInputStream dis = new DataInputStream(s.getInputStream());
                int id = dis.readInt();
                String name = dis.readUTF();
                User user = new User(name,id);

                dos.close();
                s.close();
                return user;
            }
        };

        Object o = Proxy.newProxyInstance(IUSerService.class.getClassLoader(),new Class[]{IUSerService.class},h);//生成代理类
        return (IUSerService)o;
    }
}

④第四个版本
特点：客户端向服务端传入需要调用的方法名，服务端在接收到之后，利用反射机制去调用对应方法,但服务端接口是写死的

package com.demo.rpc04;

import com.demo.IUSerService;

public class Client {
    public static void main(String[] args) throws Exception
    {
        Object stub = Stub.getStub();
        System.out.println(((IUSerService)stub).getUSerById(123));

    }
}
--------------------------------------------------------------------------------------
package com.demo.rpc04;

import com.demo.IUSerService;
import com.demo.User;
import com.demo.rpc01.USerServiceImpl;

import java.io.*;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static boolean running = true;
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(8888);
        while(running)
        {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
        ss.close();

    }

    private static void process(Socket s) throws Exception
    {

        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();

        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        ObjectInputStream oos = new ObjectInputStream(in);

        String methodName = oos.readUTF();//读入方法名
        Class[] parameterTypes = (Class[]) oos.readObject();//读入方法参数类型
        Object[] args = (Object[]) oos.readObject();//读入方法参数

        IUSerService serService = new USerServiceImpl();
        Method method = serService.getClass().getMethod(methodName,parameterTypes);//调用方法
        User user = (User)method.invoke(serService,args);



        dos.writeInt(user.getId());
        dos.writeUTF(user.getName());

        dos.flush();
    }
}
-------------------------------------------------------------------------------------------
package com.demo.rpc04;

import com.demo.IUSerService;
import com.demo.User;

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;

public class Stub {
    public static Object getStub(){
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Socket s = new Socket("127.0.0.1",8888);
                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());

                String methodName = method.getName();
                Class[] parameterTypes = method.getParameterTypes();//获取参数类型数组，这是防止重载带来的错误
                oos.writeUTF(methodName);
                oos.writeObject(parameterTypes);
                oos.writeObject(args);//方法参数
                oos.flush();

                DataInputStream dis = new DataInputStream(s.getInputStream());
                int id = dis.readInt();
                String name = dis.readUTF();
                User user = new User(name,id);

                oos.close();
                s.close();
                return user;

            }
        };

        Object o = Proxy.newProxyInstance(IUSerService.class.getClassLoader(),new Class[]{IUSerService.class},h);//生成代理类
        return o;
    }
}

⑤第五个版本
特点：只把Stub的getStub的返回值换成了IUserService,在客户端不用强转了

package com.demo.rpc05;

import com.demo.IUSerService;

public class Client {
    public static void main(String[] args) throws Exception
    {
        IUSerService stub = Stub.getStub();
        System.out.println(stub.getUSerById(123));

    }
}
---------------------------------------------------------------------------------------
package com.demo.rpc05;

import com.demo.IUSerService;
import com.demo.User;
import com.demo.rpc01.USerServiceImpl;

import java.io.*;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static boolean running = true;
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(8888);
        while(running)
        {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
        ss.close();

    }

    private static void process(Socket s) throws Exception
    {

        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();

        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        ObjectInputStream ois = new ObjectInputStream(in);
        ObjectOutputStream oos = new ObjectOutputStream(out);

        String methodName = ois.readUTF();//读入方法名
        Class[] parameterTypes = (Class[]) ois.readObject();//读入方法参数类型
        Object[] args = (Object[]) ois.readObject();//读入方法参数

        IUSerService serService = new USerServiceImpl();
        Method method = serService.getClass().getMethod(methodName,parameterTypes);//调用方法
        User user = (User)method.invoke(serService,args);


        oos.writeObject(user);

        dos.flush();
    }
}
-----------------------------------------------------------------------------------------------------
package com.demo.rpc05;

import com.demo.IUSerService;
import com.demo.User;

import java.io.DataInputStream;
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.Socket;

public class Stub {
    public static IUSerService getStub(){
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Socket s = new Socket("127.0.0.1",8888);
                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
                ObjectInputStream ois = new ObjectInputStream(s.getInputStream());

                String methodName = method.getName();
                Class[] parameterTypes = method.getParameterTypes();//获取参数类型数组，这是防止重载带来的错误
                oos.writeUTF(methodName);
                oos.writeObject(parameterTypes);
                oos.writeObject(args);//方法参数
                oos.flush();


                User user = (User)ois.readObject();

                oos.close();
                ois.close();
                s.close();

                return user;

            }
        };

        Object o = Proxy.newProxyInstance(IUSerService.class.getClassLoader(),new Class[]{IUSerService.class},h);//生成代理类
        return (IUSerService) o;
    }
}

⑥第六个版本
特点：客户端传入所需业务的接口，服务端从注册表内找到相关类，再根据传入的方法调用业务

package com.demo.rpc06;

import com.demo.IUSerService;

public class Client {
    public static void main(String[] args) throws Exception
    {
        IUSerService serService = (IUSerService) Stub.getStub(IUSerService.class);
        System.out.println(serService.getUSerById(123));

    }
}
---------------------------------------------------------------------------------------------------
package com.demo.rpc06;

import com.demo.IUSerService;
import com.demo.User;
import com.demo.rpc01.USerServiceImpl;

import java.io.*;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static boolean running = true;
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(8888);
        while(running)
        {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
        ss.close();

    }

    private static void process(Socket s) throws Exception
    {

        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();

        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        ObjectInputStream ois = new ObjectInputStream(in);
        ObjectOutputStream oos = new ObjectOutputStream(out);

        String className = ois.readUTF();//读入类名
        String methodName = ois.readUTF();//读入方法名
        Class[] parameterTypes = (Class[]) ois.readObject();//读入方法参数类型
        Object[] args = (Object[]) ois.readObject();//读入方法参数

        Class clazz = null;

        //从服务注册表找到具体类
        clazz = USerServiceImpl.class;

        Method method = clazz.getMethod(methodName,parameterTypes);//调用方法
        User user = (User)method.invoke(clazz.getDeclaredConstructor().newInstance(),args);


        oos.writeObject(user);

        dos.flush();
    }
}
----------------------------------------------------------------------------------------------------
package com.demo.rpc06;

import com.demo.HessionUtils.HessianUtils;
import com.demo.IUSerService;
import com.demo.User;

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.Socket;

public class Stub {
    public static Object getStub(Class clazz){

        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Socket s = new Socket("127.0.0.1",8888);
                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
                ObjectInputStream ois = new ObjectInputStream(s.getInputStream());


                String clazzName = clazz.getName();
                String methodName = method.getName();
                Class[] parameterTypes = method.getParameterTypes();//获取参数类型数组，这是防止重载带来的错误

                oos.writeUTF(clazzName);
                oos.writeUTF(methodName);
                oos.writeObject(parameterTypes);
                oos.writeObject(args);//方法参数
                oos.flush();


                Object o = HessianUtils.deserialize(ois.readAllBytes());

                oos.close();
                ois.close();
                s.close();

                return o;

            }
        };

        Object o = Proxy.newProxyInstance(clazz.getClassLoader(),new Class[]{clazz},h);//生成代理类
        return o;
    }
}

⑦第七个版本
特点：把Stub的getStub的返回值换成了Object，这样，传入不同的接口，就能调用不同的业务了

package com.demo.rpc07;

import com.demo.IProductService;
import com.demo.IUSerService;
import com.demo.rpc06.Stub;

public class Client {
    public static void main(String[] args) throws Exception
    {
        IProductService serService = (IProductService) Stub.getStub(IProductService.class);
        System.out.println(serService.getProById(123));

    }
}
-------------------------------------------------------------------------------------
package com.demo.rpc07;

import com.demo.Product;
import com.demo.User;
import com.demo.rpc01.USerServiceImpl;

import java.io.*;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static boolean running = true;
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(8888);
        while(running)
        {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
        ss.close();

    }

    private static void process(Socket s) throws Exception
    {

        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();

        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        ObjectInputStream ois = new ObjectInputStream(in);
        ObjectOutputStream oos = new ObjectOutputStream(out);

        String className = ois.readUTF();//读入类名
        String methodName = ois.readUTF();//读入方法名
        Class[] parameterTypes = (Class[]) ois.readObject();//读入方法参数类型
        Object[] args = (Object[]) ois.readObject();//读入方法参数

        Class clazz = null;

        //从服务注册表找到具体类
        clazz = ProductServiceImpl.class;

        Method method = clazz.getMethod(methodName,parameterTypes);//调用方法
        Product product = (Product)method.invoke(clazz.getDeclaredConstructor().newInstance(),args);


        oos.writeObject(product);

        dos.flush();
    }
}
---------------------------------------------------------------------------------------------------------
package com.demo.rpc07;

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.Socket;

public class Stub {
    public static Object getStub(Class clazz){

        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Socket s = new Socket("127.0.0.1",8888);
                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
                ObjectInputStream ois = new ObjectInputStream(s.getInputStream());


                String clazzName = clazz.getName();
                String methodName = method.getName();
                Class[] parameterTypes = method.getParameterTypes();//获取参数类型数组，这是防止重载带来的错误

                oos.writeUTF(clazzName);
                oos.writeUTF(methodName);
                oos.writeObject(parameterTypes);
                oos.writeObject(args);//方法参数
                oos.flush();


                Object o = ois.readObject();

                oos.close();
                ois.close();
                s.close();

                return o;

            }
        };

        Object o = Proxy.newProxyInstance(clazz.getClassLoader(),new Class[]{clazz},h);//生成代理类
        return o;
    }
}

⑧第八个版本
特点：Hessian的简单用法

package com.demo.rpc08_Hessian01;

import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import com.demo.User;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.HashMap;

public class HelloHessian {
    public static void main(String[] args) throws Exception
    {
        User user = new User("zhangsan",1);
        System.out.println("hession:"+serialize(user).length);
    }

    public static byte[] serialize(Object o) throws Exception
    {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        Hessian2Output output = new Hessian2Output(baos);
        output.writeObject(o);
        output.flush();
        byte[] bytes = baos.toByteArray();
        baos.close();
        output.close();
        return bytes;
    }

    public static Object deserialize(byte[] bytes) throws Exception
    {
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
        Hessian2Input input = new Hessian2Input(bais);
        Object o = input.readObject();
        bais.close();
        input.close();
        return o;

    }

}

⑨第九个版本
特点：对比JDK序列化和Hessian序列化

package com.demo.rpc09_Hessian02;

import com.caucho.hessian.io.Hessian2Output;
import com.demo.User;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.ObjectOutputStream;

public class HessianVsJdk {
    public static void main(String[] args) throws Exception
    {
        User user = new User("zhangsan",1);
        System.out.println("Hessian:"+hessianSerial(user).length);
        System.out.println("JDK:"+jdkSerial(user).length);
    }
    public static byte[] hessianSerial(Object o) throws Exception
    {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        Hessian2Output output = new Hessian2Output(out);
        output.writeObject(o);
        output.flush();
        byte[] bytes = out.toByteArray();
        out.close();
        output.close();
        return bytes;
    }
    public static byte[] jdkSerial(Object o) throws Exception
    {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(o);
        oos.flush();
        byte[] bytes = out.toByteArray();
        out.close();
        oos.close();
        return bytes;
    }
}