手写RPC框架（十一）

v2.2

更新：采用两种辅助的序列化框架kyro和protobuf、自带的进行传输，以减少JDK序列化和反序列化所带来的的缺点，我就是写三个对应的编解码器即可 然后还有一个相应的注解

• 设计传送对象

  package serialization.entity;
  
  
  import java.io.Serializable;
  
  //这是普通进行序列化传递需要
  //千万注意要实现序列化接口
  
  //接口一定要实现正确
  public class Person implements Serializable {
      private String name;
  
      //构造方法
      public  Person(String name)
      {
          this.name = name;
      }
  
      public String getName()
      {
          return name;
      }
  
  }
  

• netty自带的传输方式，对象编解码器，集成了一个方法根据，传入的方法的参数和返回值进行编解码器的设置

  package codec;
  
  import annotation.CodecSelector;
  import exception.RpcException;
  import io.netty.channel.ChannelPipeline;
  import io.netty.handler.codec.serialization.ClassResolvers;
  import io.netty.handler.codec.serialization.ObjectDecoder;
  import io.netty.handler.codec.serialization.ObjectEncoder;
  
  import io.netty.handler.codec.string.StringDecoder;
  import io.netty.handler.codec.string.StringEncoder;
  import serialization.Serialization;
  
  import java.lang.reflect.Method;
  
  //公共类 根据对应选择的注解进行编码器的添加
  public class AddCodec {
  
      /**
       *
       * @param pipeline
       * @param method 方法，来获取对应的输入输出类
       * @throws RpcException
       */
      public static  void addCodec(ChannelPipeline pipeline, Method method,boolean isConsumer) throws RpcException {
          //根据注解进行编解码器的选择
          CodecSelector annotation = Serialization.class.getAnnotation(CodecSelector.class);
  
          //目前而来我的传输 传入的参数都是一个 所以根据这一个传入和返回的参数的类型进行判断
          //下面是我传入的参数 和传出的参数
          Class<?> returnType = method.getReturnType();
          Class<?> parameterType = method.getParameterTypes()[0];
  
          String codec = annotation.Codec();
          switch (codec)
          {
              case "ObjectCodec":
                  if (returnType!=String.class&&parameterType!=String.class)
                  {
                      pipeline.addLast(new ObjectEncoder());
                      //传的参是固定写法
                      pipeline.addLast(new ObjectDecoder(Integer.MAX_VALUE,
                              ClassResolvers.weakCachingResolver(null)));
                  }
                  else if (returnType!=String.class&&parameterType==String.class)
                  {
                      //如果是客户端的话那么传出的是服务端传入的  所以这边编码那边就是解码
                      if (isConsumer)
                      {
                          //根据传入传出进行对应的编码
                          pipeline.addLast(new StringEncoder());
                          pipeline.addLast(new ObjectDecoder(Integer.MAX_VALUE,
                                  ClassResolvers.weakCachingResolver(null)));
                      }
                      else
                      {
                          pipeline.addLast(new ObjectEncoder());
                          pipeline.addLast(new StringDecoder());
                      }
  
                  }
                  else if (returnType==String.class&&parameterType!=String.class)
                  {
                      //客户端 会对参数进行编码，服务端是解码
                      if (isConsumer)
                      {
                          pipeline.addLast(new ObjectEncoder());
                          pipeline.addLast(new StringDecoder());
                      }
                      else
                      {
                          pipeline.addLast(new StringEncoder());
                          pipeline.addLast(new ObjectDecoder(Integer.MAX_VALUE,
                                  ClassResolvers.weakCachingResolver(null)));
                      }
                  }
                  else
                  {
                      //因为传入参数和传出都是字符串类型 所以就传入字符串编解码器
                      pipeline.addLast(new StringEncoder());
                      pipeline.addLast(new StringDecoder());
                  }
                  return;
              case "protobuf":  //添加protobuf的编解码器
                  return;
              case "kryo": //添加kryo的编解码器
                  return;
              default:  //如果都不是那就不加了
                  return;
          }
      }
  }
  
  

• 选取序列化对象对应的注解

  package annotation;
  
  import java.lang.annotation.ElementType;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.lang.annotation.Target;
  
  //根据该注解判断选择当遇到传对象的相应的方法时，采用什么编解码方式
  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  public @interface CodecSelector {
      String Codec() default "ObjectCodec";
  }
  
  

• BUG

  • 问题：在实现传输JDK自带序列化传输时，编解码器仿佛出现了问题 只是连接上了 并不能读取
  • 编解码器的问题，因为不论解码器handler还是编码器handler即接收的消息类型必须于待处理的消息类型一致，否则该handler不会被执行
  • 还有个错误就是实现序列化的时候，用Serializable 自己设置了一个Serialization 实现这个去了… 不该错的