项目笔记——RPC框架_rpc学习笔记-CSDN博客

本文链接：https://blog.csdn.net/qq_46107726/article/details/124217319

文章目录

RPC知识

流程图

RPC框架思路

什么是RPC

核心：动态代理+网络传输

RPC（Remote Procedure Call）—远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。比如两个不同的服务 A、B 部署在两台不同的机器上，那么服务 A 如果想要调用服务 B 中的某个方法该怎么办呢？使用 HTTP请求 当然可以，但是可能会比较慢而且一些优化做的并不好。 RPC 的出现就是为了解决这个问题。

最终解决的问题：让分布式或者微服务系统中不同服务之间的调用像本地调用一样简单。

为什么用 RPC，不用 HTTP(拓展)

首先需要指正，这两个并不是并行概念。RPC 是一种设计，就是为了解决不同服务之间的调用问题，完整的 RPC 实现一般会包含有 传输协议 和 序列化协议 这两个。

而 HTTP 是一种传输协议，RPC 框架完全可以使用 HTTP 作为传输协议，也可以直接使用 TCP，使用不同的协议一般也是为了适应不同的场景。

使用 TCP 和使用 HTTP 各有优势：

传输效率：

TCP，通常自定义上层协议，可以让请求报文体积更小
HTTP：如果是基于HTTP 1.1 的协议，请求中会包含很多无用的内容

性能消耗，主要在于序列化和反序列化的耗时

TCP，可以基于各种序列化框架进行，效率比较高
HTTP，大部分是通过 json 来实现的，字节大小和序列化耗时都要更消耗性能

跨平台：

TCP：通常要求客户端和服务器为统一平台
HTTP：可以在各种异构系统上运行

总结：
RPC 的 TCP 方式主要用于公司内部的服务调用，性能消耗低，传输效率高。HTTP主要用于对外的异构环境，浏览器接口调用，APP接口调用，第三方接口调用等。

技术栈

网络传输:netty框架(nio),基于tcp长连接有简单的应用层消息头

解决粘包：通过自定义协议的消息头长度分割

序列化：Kryo

注册中心：nacos

生产端io和业务分离

流程

消费端 生产端

将接口的方法实现注册在map中，并将服务对应服务器的ip和端口注册在注册中心

消费端通过动态代理远程调用接口方法

远程调用需要网络传输请求

注册中心查找服务的ip和端口，通过负载均衡选择具体哪个

包装协议头，请求序列化发送

阻塞读取协议头，反序列化为请求对象

map中找到请求的服务，并交给线程池业务处理

线程池处理后，发送响应，加协议头，将对象序列化

反序列化后得到结果

服务注册

意义/场景

map注册：服务生产方提前将接口的方法的信息和实例存在map中，消费的远程调用的请求封装着服务信息，通过服务信息找到生产端map中的key-value执行，生产端将执行结果网络传输回消费端。

注册中心：如果无注册中心的话，必须将ip和端口写死在消费端代码中。如果换服务器或者消费端代码中写死的那台宕机了但其它可以提供该服务的服务器正常运行，非常不方便。

test

注册接口和接口实现类

 server.serverRegister(Calculate.class,new CalculateImpl());

服务的POJO类

服务信息

用于区分服务，查找服务。是后面生产端本地map的key,是nacos注册中心的服务名

ServiceDescriptor类的属性

pack:proto class:ServiceDescriptor

	private String clazz;
    private String method;
    private String returnType;
    private String parameterType; //将参数类型的集合压缩为一个字符串

整合信息为一个字符串用于存储和查找

pack:proto class:ServiceDescriptor

public String toString()
{
    return clazz
            +"."+method
            +"."+returnType
            +"."+parameterType
            ;
}

获取ServiceDescriptor

根据class对象和方法对象得到服务信息

pack:proto class:ServiceDescriptor

public static ServiceDescriptor get(Class clazz, Method method)
{
    	ServiceDescriptor serviceDescriptor=new ServiceDescriptor();
        serviceDescriptor.setClazz(clazz.getName());
        serviceDescriptor.setMethod(method.getName());
        serviceDescriptor.setReturnType(method.getReturnType().getName());

        Class[] parameterClass=method.getParameterTypes();
        String parameters="";
        for(int i=0;i<parameterClass.length;i++)
        {
            parameters+=parameterClass[i].getName().charAt(0);
        }
        System.out.println("参数"+parameters);
        serviceDescriptor.setParameterType(parameters);
        return serviceDescriptor;
}

服务实例

ServiceInstance类

private Object target;
private Method method;

是服务的实例通过反射执行方法

注册模块主体

serviceDescriptor=ServiceDescriptor. get(interfaceClass,method); 将接口方法转为服务信息

services.put(serviceDescriptor,serviceInstance); 将服务信息和实例存入map中

NacosServiceRegistry .register(serviceDescriptor .toString(),new InetSocketAddress(host,port));将服务生产方的存入注册中心中

package :service class: Register

   private Map<ServiceDescriptor, ServiceInstance> services;
   private String host;
   private int port;

   public Register(String host,int port){
        this.host=host;
        this.port=port;
        this.services=new ConcurrentHashMap<>();
    }


public <T> void register(Class<T> interfaceClass,T bean) throws InstantiationException, IllegalAccessException {
    Method[] methods= ReflectionUtils.getPublicMethod(interfaceClass);
    System.out.println("enter2");
    for(Method method:methods)
    {
        ServiceInstance serviceInstance=new ServiceInstance(bean,method);
        ServiceDescriptor serviceDescriptor=ServiceDescriptor.get(interfaceClass,method);
        System.out.println("map-put"+serviceDescriptor);
        services.put(serviceDescriptor,serviceInstance);
        System.out.println("服务名"+serviceDescriptor.toString());
        NacosServiceRegistry.register(serviceDescriptor.toString(),new InetSocketAddress(host,port));
        System.out.println(serviceDescriptor.getClazz());
        //logger.info("register————————{} ",serviceDescriptor);
    }
}

注册到注册中心

nacos注册方法 namingService.registerInstance(serviceName, inetSocketAddress.getHostName(), inetSocketAddress.getPort());

package: nacos class:NacosServiceRegistry

 private static final String SERVER_ADDR = "127.0.0.1:8848";
    private static NamingService namingService ;
    

    static {
        try {
            namingService = NamingFactory.createNamingService(SERVER_ADDR);
        } catch (NacosException e) {
            logger.error("连接到Nacos时有错误发生: ", e);

            }
        }       

public static void register(String serviceName, InetSocketAddress inetSocketAddress) {
        try {
            namingService.registerInstance(serviceName, inetSocketAddress.getHostName(), inetSocketAddress.getPort());
        } catch (NacosException e) {
            logger.error("注册服务时有错误发生:", e);
        }
    }

注册中心注销

场景

服务器关闭，但注册中心还存在服务信息指向该服务器的地址，造成发送数据失败。特别是负载均衡的情况下，可能会选择了关闭的服务器而未选择运行的服务器。为了保证一致性所以需要注销功能

注销是在服务器的jvm运行关闭后，触发钩子函数，创建线程执行nacos服务注销函数。

注销的钩子函数及前置

服务端消费者添加钩子函数

pack:netty class:Server

ChannelFuture channelFuture = serverBootstrap.bind(this.port).sync();
            ShutdownHook.getShutdownHook().addClearAllHook(register.getServiceMap(),new InetSocketAddress(host,port));
            channelFuture.channel().closeFuture().sync();

钩子函数的实现

对象的实例是获取是单例模式，钩子函数就是在系统调用的时候触发。这里是jvm运行结束时，子线程调用nacos注销函数。

pack:util class:ShutdownHook

public class ShutdownHook {

    private static final Logger logger = LoggerFactory.getLogger(ShutdownHook.class);

   // private final ExecutorService threadPool = ThreadPoolFactory.createDefaultThreadPool("shutdown-hook");
    private static final ShutdownHook shutdownHook ;

    static {
        shutdownHook=new ShutdownHook();
    }

    public static ShutdownHook getShutdownHook() {
        return shutdownHook;
    }  //单例模式

    public void addClearAllHook(Map<ServiceDescriptor, ServiceInstance> serviceNames, InetSocketAddress address) {
        logger.info("关闭后将自动注销所有服务");
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            NacosServiceRegistry.clearRegistry(serviceNames,address);

        }));
    }

}

注册中心注销

nacos服务注销函数

pack:nacos class:NacosServiceRegistry

public static void clearRegistry(Map<ServiceDescriptor,ServiceInstance> serviceNames, InetSocketAddress address) {
    if(!serviceNames.isEmpty() && address != null) {
        String host = address.getHostName();
        int port = address.getPort();

        for(ServiceDescriptor iterator :serviceNames.keySet())
        {
            try {
                namingService.deregisterInstance(iterator.toString(), host, port);
            } catch (NacosException e) {
                logger.error("注销服务 {} 失败", iterator.toString(), e);
            }
        }
    }
}

远程调用

意义

消费端（客户）进行远程调用，像使用本地方法一样使用其它服务器实现的方法。远程调用是微服务的基础

定义接口

生产端与服务端接口统一

消费端本地无需实现接口，实现接口的实现类在生产端（服务）。基于远程调用，消费端只通过代理实例调用接口方法从而执行服务

test

本地执行远程方法底层是动态代理

pack:example class:ClientTest

       Thread thread1=new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                Client client=new Client();
                client.initClient();
                ProxyRemote proxy=new ProxyRemote(client);
                Calculate calculate=proxy.getProxy(Calculate.class);
                System.out.println ("线程"+Thread.currentThread()+" 结果"+calculate.add(1,3) );
            }

        });

重写jdk动态代理的invoke

NacosServiceRegistry.lookupService(request.getServiceDescriptor().toString()); 查找服务所在服务器的ip和端口

RpcResponse response = client.sendRequest(request, inetSocketAddress.getHostName(), inetSocketAddress.getPort()); 向服务端生产者发送请求，获取响应(即远程方法执行结果)

pack:remote class:ProxyRemote

 @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        RpcRequest request=new RpcRequest();
        request.setServiceDescriptor(ServiceDescriptor.get(aClass,method));
        request.setParameter(args);
        System.out.println("发送的descriptor"+request.getServiceDescriptor());
        InetSocketAddress inetSocketAddress =NacosServiceRegistry.lookupService(request.getServiceDescriptor().toString());
        if(inetSocketAddress!=null) {
            RpcResponse response = client.sendRequest(request, inetSocketAddress.getHostName(), inetSocketAddress.getPort());
            System.out.println("invoke" + response.getData());
            return response.getData();
        }
        return null;
    }

拓展

jdk和CGlib

服务发现

从nacos注册中心根据服务信息查找注册服务的ip和端口

nacos服务发现方法：namingService.getAllInstances(serviceName)

通过负载均衡策略选择具体服务器

pack:nacos class:NacosServiceRegistry

	private static final String SERVER_ADDR = "127.0.0.1:8848";
    private static NamingService namingService ;
    private static int index=0;

    static {
        try {
            namingService = NamingFactory.createNamingService(SERVER_ADDR);
        } catch (NacosException e) {
            logger.error("连接到Nacos时有错误发生: ", e);

            }
        }    

public static InetSocketAddress lookupService(String serviceName) {
        try {
            List<Instance> instances = namingService.getAllInstances(serviceName);
            if(instances.size()==0) {
                System.out.println("未找到服务");
                return null;
            }
            Instance instance = instances.get((index++)%instances.size());
            return new InetSocketAddress(instance.getIp(), instance.getPort());
        } catch (NacosException e) {
            logger.error("获取服务时有错误发生:", e);
        }
        return null;
    }

负载均衡

知识

负载均衡算法 - 简书 (jianshu.com)

使用

轮询法

各个服务节点被访问的概率也基本相同，也主要应用在各个服务节点性能差异不大的情况下。

pack:nacos class:NacosServiceRegistry

Instance instance = instances.get((index++)%instances.size());

网络传输

netty知识

(123条消息) Netty学习笔记(一) IO_NUAA庞的博客-CSDN博客

(123条消息) Netty学习笔记(二)netty_NUAA庞的博客-CSDN博客

POJO类

RpcRequest

pack:proto class:RpcRequest

@Data
public class RpcRequest {
    private ServiceDescriptor serviceDescriptor; //服务信息
    private Object[] parameter;  //参数
    private int heart=0; //判断是否为心跳包
}

RpcResponse

@Data
public class RpcResponse {
    private int code=0;
    private String message="ok";
    private Object data;  //调用服务返回的结果

}

netty心跳

场景及简介

心跳机制是检查长连接是否还可连，了解对方是否宕机，断开则close节约资源或重新连接

正常来说，应该是客户端发心跳包服务端回复心跳包。但服务端并发量远大于客户端，所以服务端知道客户端宕机释放资源比较重要，而客户端没并发有多余的长连接影响不大，所以也不需要服务器给大量客户端发心跳包而是采用不回复。因为相比数据库主从间的心跳涉及从代替主，netty的心跳更多是为了关闭无效的长连接减少资源占用

消费端添加IdleStateHandler处理器,设置写空闲5s

pack:netty class:Client

.addLast(new IdleStateHandler(0, 5, 0, TimeUnit.SECONDS))

写空闲5s触发发送心跳包,心跳包RpcRequest的heart设置为1其它数据为空。heart为1的包服务端生产者不回复响应包

pack:netty class:ClientHandler

@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
    if (evt instanceof IdleStateEvent) {
        IdleState state = ((IdleStateEvent) evt).state();
        if (state == IdleState.WRITER_IDLE) {
            logger.info("发送心跳包 [{}]", ctx.channel().remoteAddress());
            Channel channel = ctx.channel();
            RpcRequest request=new RpcRequest();
            request.setHeart(1);
            channel.writeAndFlush(request);
        }
    } else {
        super.userEventTriggered(ctx, evt);
    }
}

生产端添加IdleStateHandler处理器,设置读空闲6s

pack:netty class:Server

pipeline.addLast(new IdleStateHandler(6, 0, 0, TimeUnit.SECONDS));

6秒读空闲，无心跳包和正常包，表示该channel对应的客户端已挂,close掉

@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
    if (evt instanceof IdleStateEvent) {
        IdleState state = ((IdleStateEvent) evt).state();
        if (state == IdleState.READER_IDLE) {
            logger.info("长时间未收到心跳包，断开连接...");
            ctx.close();
        }
    } else {
        super.userEventTriggered(ctx, evt);
    }
}

串联其它模块

消费端

消费端远程调用模块调用发送request方法

pack:netty class:Client

public class Client {

    private ClientHandler clientHandler;
    private  Bootstrap bootstrap;
    private ChannelFuture channelFuture;
    private RpcResponse response;
    private int status=0;
  
    ...............

public RpcResponse sendRequest(RpcRequest rpcRequest,String host,int port) throws InterruptedException {

    channelFuture = bootstrap.connect(host, port).sync();
    Channel channel = channelFuture.channel();

    //通过channel 发送到服务器端
    channel.writeAndFlush(rpcRequest);

    Thread t = Thread.currentThread();
    System.out.println("线程2"+t.getName());
    Thread thread=new Thread();
    while(status==0)
    {
        thread.sleep(30);
    }
    status=0;
    if(response!=null)
        return response;
    else
    {
        System.out.println("response is null");
        return null;
    }

}

由于消费端发送请求得到响应需要时间，需要阻塞后续代码。等待响应获得后再进行后续处理

每个消费端是个实例，status是成员变量，是每个消费端的私有变量，不存在并发无线程不安全。所以不加锁。消费端自己的请求是串行的。生产端考虑并发而消费端无需考虑。

Thread thread=new Thread();
    while(status==0)
    {
        thread.sleep(30);
    }
    status=0;

获取response

pack:netty class:ClientHandler

@Override
public  void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    RpcResponse response=(RpcResponse) msg;
    try {
        logger.info(String.format("客户端接收到消息: %s", response));
        //System.out.println(response.getCode()+" "+response.getMessage());
        client.setResponse(response);
        client.setStatus(); //status设为1
        Thread t = Thread.currentThread();
        System.out.println("线程"+t.getName());

    } finally {
        ReferenceCountUtil.release(msg);
    }
}

生产端

RpcRequest rpcRequest=(RpcRequest)msg; 获取请求

ServiceInstance serviceInstance = register.getService(rpcRequest); 根据请求的服务信息找到对应的服务实例

Executor.getExecutor().execute(serviceInstance, rpcRequest, ctx.channel()); 将服务实例和参数和channel(确保能发送给对应的消费端)交给业务线程池，读io与业务处理、响应分离。

pack:netty class:ServerHandler

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

    RpcRequest rpcRequest=(RpcRequest)msg;
    if(rpcRequest.getHeart()==0) {
        logger.info("服务器接收到请求: {}", rpcRequest);
        RpcResponse response = new RpcResponse();
        ServiceInstance serviceInstance = register.getService(rpcRequest);
        System.out.println(serviceInstance);
        Executor.getExecutor().execute(serviceInstance, rpcRequest, ctx.channel());
    }
}

业务处理

场景

业务处理如果放在handler中，那么io线程与业务线程是同一个。io限制了处理能力，使性能有瓶颈。

业务和读分离，符合多线程reactor模式。io读取后将处理和写交给业务线程池后，可以继续io读。

实现

pack:netty class:ServerHandler

生产端读handler调用

Executor.getExecutor().execute(serviceInstance, rpcRequest, ctx.channel());

executor

pack:service

public class Executor {
    private static final int CORE_POOL_SIZE = 5;
    private static final int MAX_POOL_SIZE = 10;
    private static final int QUEUE_CAPACITY = 100;
    private static final Long KEEP_ALIVE_TIME = 1L;

    private  ThreadPoolExecutor executor=new ThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());;

    static Executor execute;

    public Object serviceInvoke(ServiceInstance serviceInstance, RpcRequest request) throws InvocationTargetException, IllegalAccessException {
        return ReflectionUtils.invoke(serviceInstance.getTarget(),serviceInstance.getMethod(),request.getParameter());
    }

    public static Executor getExecutor()
    {
        if(execute==null)
        {
            synchronized (Executor.class)
            {
                if(execute==null)
                {
                    execute=new Executor();
                }
            }
        }
        return execute;
    }

    public void execute(ServiceInstance serviceInstance, RpcRequest request, Channel channel)
    {
        executor.execute(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                RpcResponse response=new RpcResponse();
                response.setData(serviceInvoke(serviceInstance,request));
                channel.writeAndFlush(response);
            }
        });
    }
    
}

getExecutor 单例模式，共用一个实例，从而共用一个线程池。

execute 将服务实例和参数和channel(确保能发送给对应的消费端)作为任务提交给线程池运行。

粘包处理

意义

粘包由tcp引起，但防止的是应用层数据间(完整的请求响应)粘而不是tcp数据包的数据之间粘。多个tcp可能装一个应用层数据，也可能一个装多个应用层数据(nagle算法)。粘发生在tcp首部拆除后，缓冲区应用层数据堆积造成混淆

tcp默认启用nagle算法(发送方原因)

一组tcp包发到缓冲区，去掉头部tcp首部，套接字读取缓冲区数据,读取数据速度慢于接收速度若无粘包处理则产生粘包。(接收方原因)

同一个应用层数据tcp下的数据可粘。不同的应用层数据需要分割。

应用层数据(http例子)和tcp:

在这里插入图片描述

应用层协议的消息长度分割(实际使用)

发送方的应用层在实际数据(消息体)之前加协议头(消息头)，tcp传输后去掉头部，接收方获得应用层数据(头和体)进行处理

1.decode(解码组件)读取缓冲区数据

2.读取消息头，消息头部各部分定长，不会乱

3.根据消息头的数据长度，创建byte数组

4.将数据的消息体读进byte数组

项目中应用

协议：

packgeCode(int)

length(int)

数据(变长)

pack:codec class:Decode

int packageCode = byteBuf.readInt();
Class<?> packageClass;
if (packageCode == 0) {
    packageClass = RpcRequest.class;
} else if (packageCode == 1) {
    packageClass = RpcResponse.class;
} else {
    logger.error("不识别的数据包: {}", packageCode);
    throw new Exception("未知数据包");
}
int length = byteBuf.readInt();
byte[] bytes = new byte[length];
byteBuf.readBytes(bytes);
Object obj = deserializer.deserialize(bytes, packageClass);
list.add(obj);

packageCode决定反序列为response or request对象

length:数据体长度

分割符分割(拓展)

在应用层数据后面加分隔符（包括\n）

使用 DelimiterBasedFrameDecoder解码器

 @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        ByteBuf decode= Unpooled.copiedBuffer("$$".getBytes(StandardCharsets.UTF_8));
        pipeline.addLast(new DelimiterBasedFrameDecoder(1024,decode) );
        pipeline.addLast(new StringDecoder());
        pipeline.addLast(new MyServerHandler());
    }

定长分割(拓展)

使用FixedLengthFrameDecoder 解码器

关闭nagle算法(拓展)

TCP/IP协议中，Nagle算法是默认开启的。那么什么是Nagle算法呢？Nagle算法通过减少需要传输的数据包，来优化网络。在内核实现中，数据包的发送和接受会先做缓存。启动TCP_NODELAY，就意味着禁用了Nagle算法。当我们不设置TCP_NODELAY时，就默认打开了Nagle算法。这个时候，我们发送的数据将会在写缓存中保存，直到保存到一定量之后，数据才会被发送。

nagle算法规则

（1）如果包长度达到MSS，则允许发送；

（2）如果该包含有FIN，则允许发送；

（3）设置了TCP_NODELAY选项，则允许发送；(关闭nagle)

（4）未设置TCP_CORK选项时，若所有发出去的小数据包（包长度小于MSS）均被确认，则允许发送；

（5）上述条件都未满足，但发生了超时（一般为200ms），则立即发送。

nagle与粘包：nagle算法开启，tcp数据包尽可能装数据，会出现一个tcp包有多份应用层数据。应用层不处理粘包开启nagle必会出现粘包。关闭nagle算法一般解决粘包，但如果接收速度快于读取速度还是会在缓冲区出现粘包。

序列化和反序列化

解码和编码

Decode组件调用反序列化方法，并且处理协议头和粘包

Encode组件调用序列化方法，并且加协议头

Kryo序列化和反序列化方法

Kryo 是一个快速高效的 Java 对象序列化框架，主要特点是高性能、高效和易用。最重要的两个特点，一是基于字节的序列化，对空间利用率较高，在网络传输时可以减小体积；二是序列化时记录属性对象的类型信息，这样在反序列化时就不会出现之前的问题了。

对比JSON

基于 JSON 的序列化器有一个毛病，就是在某个类的属性反序列化时，如果属性声明为 Object 的，就会造成反序列化出错，通常会把 Object 属性直接反序列化成 String 类型，就需要其他参数辅助序列化。并且，JSON 序列化器是基于字符串（JSON 串）的，占用空间较大且速度较慢。

pack:codec class:KryoSerializer

public class KryoSerializer  {

    private static final Logger logger = LoggerFactory.getLogger(KryoSerializer.class);

    private static final ThreadLocal<Kryo> kryoThreadLocal = ThreadLocal.withInitial(() -> {
        Kryo kryo = new Kryo();
        kryo.register(RpcResponse.class);
        kryo.register(RpcRequest.class);
        kryo.setReferences(true);
        kryo.setRegistrationRequired(false);
        return kryo;
    });


    public byte[] serialize(Object obj) throws Exception {
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
             Output output = new Output(byteArrayOutputStream)) {
            Kryo kryo = kryoThreadLocal.get();
            kryo.writeObject(output, obj);
            kryoThreadLocal.remove();
            return output.toBytes();
        } catch (Exception e) {
            logger.error("序列化时有错误发生:", e);
            throw new Exception("序列化异常");
        }
    }


    public Object deserialize(byte[] bytes, Class<?> clazz) throws Exception {
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
             Input input = new Input(byteArrayInputStream)) {
            Kryo kryo = kryoThreadLocal.get();
            Object o = kryo.readObject(input, clazz);
            kryoThreadLocal.remove();
            return o;
        } catch (Exception e) {
            logger.error("反序列化时有错误发生:", e);
            throw new Exception("反序列化异常");
        }
    }


}

序列化方法(拓展)

JSON 是一种轻量级的数据交换语言，该语言以易于让人阅读的文字为基础，用来传输由属性值或者序列性的值组成的数据对象，类似 xml，Json 比 xml更小、更快更容易解析。JSON 由于采用字符方式存储，占用相对于字节方式较大，并且序列化后类的信息会丢失，可能导致反序列化失败。

剩下的都是基于字节的序列化。

Kryo 是一个快速高效的 Java 序列化框架，旨在提供快速、高效和易用的 API。无论文件、数据库或网络数据 Kryo 都可以随时完成序列化。 Kryo 还可以执行自动深拷贝、浅拷贝。这是对象到对象的直接拷贝，而不是对象->字节->对象的拷贝。kryo 速度较快，序列化后体积较小，但是跨语言支持较复杂。

Hessian 是一个基于二进制的协议，Hessian 支持很多种语言，例如 Java、python、c++,、net/c#、D、Erlang、PHP、Ruby、object-c等，它的序列化和反序列化也是非常高效。速度较慢，序列化后的体积较大。

protobuf（Protocol Buffers）是由 Google 发布的数据交换格式，提供跨语言、跨平台的序列化和反序列化实现，底层由 C++ 实现，其他平台使用时必须使用 protocol compiler 进行预编译生成 protoc 二进制文件。性能主要消耗在文件的预编译上。序列化反序列化性能较高，平台无关。