笔记5：Netty的自定义RPC(JSON序列化协议)

最新推荐文章于 2022-09-16 10:21:27 发布
最新推荐文章于 2022-09-16 10:21:27 发布
阅读量663 收藏 5
点赞数
分类专栏： 笔记 Java 文章标签： java netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lossdate/article/details/113274766
版权
笔记 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
Java
14 篇文章 0 订阅
订阅专栏

目标：Netty的自定义RPC，序列化协议为JSON，使用fastjson作为JSON框架，并根据RpcRequest实体作为通信协议，服务端需根据客户端传递过来的RpcRequest对象通过反射，动态代理等技术，最终能够执行目标方法，返回字符串"success"。

  1. 结构
    分为三个模块：rpc-common 通用模块, rpc-consumer 客户端模块, rpc-my-provider客服端模块
    在这里插入图片描述

  2. rpc-common模块
    在这里插入图片描述
    1）接口

    public interface IUserService {

    public RpcResponse sayHello(String msg);

}

    2）JSON序列化工具

    public interface Serializer {
    /**
     * java对象转换为二进制
     */
    byte[] serialize(Object object) throws IOException;
    
    /**
     * 二进制转换成java对象
     */
    <T> T deserialize(Class<T> clazz, byte[] bytes) throws IOException;
}

    public class JSONSerializer implements Serializer {

    @Override
    public byte[] serialize(Object object) {
        return JSON.toJSONBytes(object);
    }
    
    @Override
    public <T> T deserialize(Class<T> clazz, byte[] bytes) {
        return JSON.parseObject(bytes, clazz);
    }
}

    3）定义编码和解码

    public class RpcEncoder extends MessageToByteEncoder {

    private Class<?> clazz;
    private Serializer serializer;
    
    public RpcEncoder(Class<?> clazz, Serializer serializer) {
        this.clazz = clazz;
        this.serializer = serializer;
    }

    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, Object msg, ByteBuf byteBuf) throws Exception {
        if (clazz != null && clazz.isInstance(msg)) {
            byte[] bytes = serializer.serialize(msg);
            byteBuf.writeInt(bytes.length);
            byteBuf.writeBytes(bytes);
        }
    }
}

    public class RpcDecoder extends ByteToMessageDecoder {

    private Class<?> clazz;
    private Serializer serializer;
    
    public RpcDecoder(Class<?> clazz, Serializer serializer) {
        this.clazz = clazz;
        this.serializer = serializer;
    }

    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
        // Check if there are at least 4 bytes readable
        if (byteBuf.readableBytes() >= 4) {
            int readInt = byteBuf.readInt();
            System.out.println("ByteToIntegerDecoder decode msg is " + readInt);
            byte[] bytes = new byte[readInt];
            byteBuf.readBytes(bytes);
            Object deserialize = serializer.deserialize(clazz, bytes);
            list.add(deserialize);
        }
    }
}

    4）定义Request和Response实体组件

    public class RpcRequest {

    /**
     * 请求对象的ID
     */
    private String requestId;

    /**
     * 类名
     */
    private String className;

    /**
     * 方法名
     */
    private String methodName;

    /**
     * 参数类型
     */
    private Class<?>[] parameterTypes;

    /**
     * 入参
     */
    private Object[] parameters;


    public String getRequestId() {
        return requestId;
    }

    public void setRequestId(String requestId) {
        this.requestId = requestId;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Class<?>[] getParameterTypes() {
        return parameterTypes;
    }

    public void setParameterTypes(Class<?>[] parameterTypes) {
        this.parameterTypes = parameterTypes;
    }

    public Object[] getParameters() {
        return parameters;
    }

    public void setParameters(Object[] parameters) {
        this.parameters = parameters;
    }
}

    public class RpcResponse {

    private String responseId;

    private String resultMsg;

    private String result;


    public String getResponseId() {
        return responseId;
    }

    public void setResponseId(String responseId) {
        this.responseId = responseId;
    }

    public String getResultMsg() {
        return resultMsg;
    }

    public void setResultMsg(String resultMsg) {
        this.resultMsg = resultMsg;
    }

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    @Override
    public String toString() {
        return "RpcResponse{" +
                "responseId='" + responseId + '\'' +
                ", resultMsg='" + resultMsg + '\'' +
                ", result='" + result + '\'' +
                '}';
    }
}

  3. rpc-consumer 客服端编写
    在这里插入图片描述
    1）netty客户端的初始化及动态代理

    public class RpcConsumer {

    /**
     * 1.创建一个线程池对象  -- 它要处理我们自定义事件
     */
    private static ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    /**
     * 2.声明一个自定义事件处理器  UserClientHandler
     */
    private static UserClientHandler userClientHandler;

    /**
     * 3.编写方法,初始化客户端  ( 创建连接池  bootStrap  设置bootstrap  连接服务器)
     */
    public static void initClient() throws InterruptedException {
        //1) 初始化UserClientHandler
        userClientHandler = new UserClientHandler();
        //2)创建连接池对象
        NioEventLoopGroup group = new NioEventLoopGroup();
        //3)创建客户端的引导对象
        Bootstrap bootstrap = new Bootstrap();
        //4)配置启动引导对象
        bootstrap.group(group)
                //设置通道为NIO
                .channel(NioSocketChannel.class)
                //设置请求协议为TCP
                .option(ChannelOption.TCP_NODELAY, true)
                //监听channel 并初始化
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        //获取ChannelPipeline
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        //设置编码
                        pipeline.addLast(new RpcEncoder(RpcRequest.class, new JSONSerializer()));
                        pipeline.addLast(new RpcDecoder(RpcResponse.class, new JSONSerializer()));

                        //添加自定义事件处理器
                        pipeline.addLast(userClientHandler);
                    }
                });
        //5)连接服务端
        bootstrap.connect("127.0.0.1", 8999).sync();
    }

    /**
     * 4.编写一个方法,使用JDK的动态代理创建对象
     * serviceClass 接口类型,根据哪个接口生成子类代理对象;   providerParam :  "UserService#sayHello#"
     */
    public static Object createProxy(Class<?> serviceClass, final String providerParam) {
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{serviceClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //1)初始化客户端client
                if(userClientHandler == null) {
                    initClient();
                }

                //2)给UserClientHandler 设置param参数
                RpcRequest rpcRequest = new RpcRequest();
                rpcRequest.setRequestId(UUID.randomUUID().toString());
                String[] classNameAndMethod = providerParam.split("#");
                rpcRequest.setClassName(serviceClass.getName());
                rpcRequest.setMethodName(classNameAndMethod[1]);
                rpcRequest.setParameters(args);
                rpcRequest.setParameterTypes(new Class[]{String.class});
                userClientHandler.setParam(rpcRequest);

                //3).使用线程池,开启一个线程处理处理call() 写操作,并返回结果
                //4)return 结果
                return executorService.submit(userClientHandler).get();
            }
        });
    }
}

    2）自定义事件处理器

    public class UserClientHandler extends ChannelInboundHandlerAdapter implements Callable {

    /**
     * 1.定义成员变量
     * context: 事件处理器上下文对象 (存储handler信息,写操作)
     * result: 记录服务器返回的数据
     * param: 记录将要返送给服务器的数据
     */
    private ChannelHandlerContext context;
    private RpcRequest param;
    private RpcResponse result;

    /**
     * 2.实现channelActive  客户端和服务器连接时,该方法就自动执行
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        this.context = ctx;
    }

    /**
     * 3.实现channelRead 当我们读到服务器数据,该方法自动执行
     */
    @Override
    public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        result = (RpcResponse) msg;
        notify();
    }

    /**
     * 4.将客户端的数写到服务器
     */
    @Override
    public synchronized Object call() throws Exception {
        context.writeAndFlush(param);
        wait();
        return result;
    }

    /**
     * 5.设置参数的方法
     */
    public void setParam(RpcRequest param) {
        this.param = param;
    }
}

    3）启动类， 向服务器发消息以及接收消息

    public class ConsumerBoot {

    /**
     * 参数定义
     */
    private static final String PROVIDER_NAME = "UserService#sayHello#";

    public static void main(String[] args) throws InterruptedException {
        //1.创建代理对象
        IUserService userService = (IUserService) RpcConsumer.createProxy(IUserService.class, PROVIDER_NAME);

        //2.循环给服务器写数据
        while (true) {
            System.out.println("客户端开始");
            RpcResponse result = userService.sayHello("Hi I am Tom, I want to play a game with u !");
            System.out.println("客服端返回：" + result.toString());
            System.out.println("客户端结束");
            //睡2s方便查看输出
            Thread.sleep(2000);
        }
    }
}

  4. rpc-my-provider 服务端编写
    在这里插入图片描述
    1）启动类服务器

    @ComponentScan(value="com.lossdate")
@SpringBootApplication
public class ServerBoot {

    public static void main(String[] args) throws InterruptedException {
        SpringApplication.run(ServerBoot.class, args);
        // 启动服务器
        UserServiceImpl.startServer("127.0.0.1", 8999);
    }

}

    2）netty客服端的初始化及返回客户端消息方法

    @Service
public class UserServiceImpl implements IUserService {

    /**
     * 将来客户单要远程调用的方法
     */
    @Override
    public RpcResponse sayHello(String msg) {
        System.out.println("You ** **! -> " + msg);
        RpcResponse rpcResponse = new RpcResponse();
        rpcResponse.setResultMsg("服务器返回数据 : " + msg);
        rpcResponse.setResult("success");
        return rpcResponse;
    }

    /**
     * 创建一个方法启动服务器
     */
    public static void startServer(String ip, int port) throws InterruptedException {
        //1.创建两个线程池对象
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workGroup = new NioEventLoopGroup();

        //2.创建服务端的启动引导对象
        ServerBootstrap serverBootstrap = new ServerBootstrap();

        //3.配置启动引导对象
        serverBootstrap.group(bossGroup, workGroup)
                //设置通道为NIO
                .channel(NioServerSocketChannel.class)
                //创建监听channel
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
                        //获取管道对象
                        ChannelPipeline pipeline = nioSocketChannel.pipeline();
                        //给管道对象pipeLine 设置编码
                        pipeline.addLast(new RpcEncoder(RpcResponse.class, new JSONSerializer()));
                        pipeline.addLast(new RpcDecoder(RpcRequest.class, new JSONSerializer()));

                        //把我们自定义的ChannelHander添加到通道中
                        pipeline.addLast(new UserServiceHandler());
                    }
                });

        //4.绑定端口
        serverBootstrap.bind(ip, port).sync();
    }
}

    3）获取客户端传来的消息，并通过反射调用sayHello方法，最后将消息传给客户端。这里需要借助实现ApplicationContextAware接口获取Bean

    public class UserServiceHandler extends ChannelInboundHandlerAdapter {

    /**
     * 当客户端读取数据时,该方法会被调用
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //注意:  客户端将来发送请求的时候会传递一个参数:  UserService#sayHello#Hi I am Tom, I want to play a game with u !
        RpcRequest rpcRequest = (RpcRequest) msg;
        System.out.println("服务端接收：" + rpcRequest.getRequestId());
        //通过反射获取class
        Class<?> aClass = Class.forName(rpcRequest.getClassName());
        //借助实现ApplicationContextAware接口获取Bean
        Object bean = SpringJobBeanFactory.getBean(aClass);
        //获取方法
        Method declaredMethod = aClass.getDeclaredMethod(rpcRequest.getMethodName(), rpcRequest.getParameterTypes());
        //invoke调用方法
        RpcResponse rpcResponse = (RpcResponse) declaredMethod.invoke(bean, rpcRequest.getParameters());

        //把调用实现类的方法获得的结果写到客户端
        rpcResponse.setResponseId(rpcRequest.getRequestId());
        ctx.writeAndFlush(rpcResponse);
    }
}

    4）ApplicationContextAware获取Bean工具

    @Component
public class SpringJobBeanFactory implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringJobBeanFactory.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    @SuppressWarnings("unchecked")
    public static <T> T getBean(Class<T> name) throws BeansException {
        if (applicationContext == null){
            return null;
        }
        return (T)applicationContext.getBean(name);
    }
}
Lossdate
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用Netty实现物联网01：XML-RPC和JSON-RPC
分享专业、有用、有趣的技术、产品、运营和管理知识。
02-24 387
和（移动）互联网不同，物联网针对的主要是一些资源有限的硬件设备，比如监控探头、烟雾感应器、温湿度感应器、车载OBD诊断器、智能电表、智能血压计等。这些硬件设备既不像个人PC电脑那样拥有较为齐全的配套支持，也不像手机那样灵活、方便、可操控，它们除了能够接受输入指令以及向外输出响应数据之外，基本上就是等于是「沉默的大多数」。所以，为了实现这些「沉默」的电子设备之间的「物物相连」和「人物相连」，实现对它们的感知、识别和管理，物联网（Internet of Things）就因此而诞生了。
netty-rpc:基于netty的自定义RPC框架
04-02
Netty RPC 基于Netty手动实现一个Java RPC框架 快速使用 约会依赖 val nettyRpcVersion = " 0.0.1-SNAPSHOT " repositories { maven { setUrl( " https://maven.pkg.github.com/helloworlde/netty-rpc " ) } } dependencies { implementation( " io.github.helloworlde:netty-rpc-core: ${ nettyRpcVersion } " ) implementation( " io.github.helloworlde:netty-rpc-client: ${ nettyRpcVersion } " ) implementation(
Netty HTTP请求获取application/json请求参数
chy2z的专栏
04-27 3347
$.ajax({ url: url, type: "POST", dataType: "json", contentType: 'application/json;charset=utf-8', data: $.toJSON({type:"2",name:"你好"}), success: function(data){ log("2----->"+
Netty 学习：通信协议和编解码
Huangjiazhen711的博客
09-16 221
实现了对象和字节数组的互转以后，我们需要实现字节数组和 Netty 通信载体 ByteBuf 的互转，包括如下两个方法。接下来我们可以约定双方的序列化方法，这里我们可以用 JSON 序列化/反序列化 为例，其他格式的类似。因为不同的数据包内容有所不一样，所以应该设置一个抽象类，由各个子类实现具体数据包的内容。对于一个具体的操作，比如登录操作，它需要的数据包需要继承并实现这个抽象类的抽象方法。序列化算法：用于标识这个协议的数据包使用什么序列化算法，比如：JSON，XML等。将字节数组转换成对应的数据包对象。
Netty万字详解 - 配置&优化
qq_51026595的博客
11-19 571
扩展序列化算法 配置文件 config.properties serialize.type=JSON 工具类 public class Config { private static final Properties PROPERTIES = new Properties(); static { try (InputStream input = Config.class.getResourceAsStream("/config.properties"))...
使用Netty通过Post发送Json格式数据
alterhz的博客
06-19 982
方式1 // Prepare the HTTP request. String host = uri.getHost() == null ? "127.0.0.1" : uri.getHost(); FullHttpRequest request = new DefaultFullHttpRequest( HttpVersion.HTTP_1_1, HttpMethod.POST, uri.getRawPath()); request.headers().set(HttpHea.
修复netty-codec-http:4.1.30解析application/json数据在Windows系统奔溃的问题
weixin_33709219的博客
02-13 1644
netty-codec-http:4.1.30解析application/json数据仍按键值对的方式解析，导致在windows系统下因为文件名错误而使程序奔溃，堆栈如下， 2019/02/13 12:33:53 ERROR [ worker@thread-1 ] c.b.m.h.DefaultExceptionHandler : io.netty.handler.codec.http.mu...
netty 处理JSON序列化（FastJSON编解码）
Lyndon的专栏
02-08 1200
解码器 编码器
【WebSocket服务器】 1.服务器netty 2.客户端creator 3.fastjson通讯协议
focus-unchanged-thing
07-25 219
1.客户端 start() { // init logic this.label.string = this.text; let socket = new WebSocket("ws://localhost:6080/ws"); // H5标准，底层做好了; socket.binaryType = "arraybuffer"; socket.onopen = function () { cc
netty自定义rpc实现
12-26
自定义rpc
Netty实现长连接通讯-连接协议为了简单json封装
09-27
Netty实现长连接通讯,连接协议为了简单json封装,如果需要协议变化可以自己封装，有问题可以联系邮箱：[email protected]
jsonrpc是一个基于Java的高性能开源RPC框架
08-07
jsonrpc是一个基于Java的高性能开源RPC框架
使用netty自定义rpc通信框架
08-23
利用netty4.0定义的rpc通信框架
Netty学习笔记_Springboot实现自定义协议.docx
12-27
Netty学习笔记_Springboot实现自定义协议.docx Netty学习笔记_Springboot实现自定义协议.docx Netty学习笔记_Springboot实现自定义协议.docx
netty实现自定义rpc.zip
12-26
netty实现自定义rpcnetty实现自定义rpcnetty实现自定义rpcnetty实现自定义rpcnetty实现自定义rpc
微信第三方获取component_verify_ticket接口
Lossdate的博客
03-21 8020
在第三方平台创建审核通过后，微信服务器会向其“授权事件接收URL”每隔10分钟定时推送component_verify_ticket。第三方平台方在收到ticket推送后也需进行解密（详细请见【消息加解密接入指引】），接收到后必须直接返回字符串success。 1. 获取component_verify_ticket接口配置 接口名要与微信开发平台第三方平台上配置的"授权事件接...
企业微信推送 - news 推送方式
Lossdate的博客
09-18 2705
企业微信推送 - news 推送方式
笔记13：配置ShardingSphere
Lossdate的博客
04-18 1495
一、简介 Apache ShardingSphere是一款开源的分布式数据库中间件组成的生态圈。它由Sharding-JDBC、 Sharding-Proxy和Sharding-Sidecar（规划中）这3款相互独立的产品组成。 他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。 Sharding-JDBC定位为轻量级Java框架，在Java的JDBC层提供的额外服务。 它使用客户端直连数据库， 以jar包形式提供服务，无需额
第三方平台为授权的小程序帐号上传小程序代码报47001问题
Lossdate的博客
04-30 1178
第三方平台为授权的小程序帐号上传小程序代码报47001问题 首先，Post数据要求ext_json需为string类型， 其次， extJson传入后端时，要确保【"】双引号未被转译为【"】， 最后，检查下数据传参名字是否写错，例ext_json在这个接口是以【_】连接命名而不是驼峰式。 JSONObject json = new JSONObject(); json.accumul...
netty自定义网络应用层协议课设
最新发布
03-23
非常感谢您的提问。关于netty自定义网络应用层协议课设，我可以给您提供一些参考资料和建议。首先，您可以了解一下netty框架的基本原理和使用方法，然后根据自己的需求和课设要求，设计和实现一个符合要求的自定义协议。具体实现过程中，您可以参考一些相关的开源项目和文档，如netty官方文档、GitHub上的netty示例代码等。同时，您还需要注意一些常见的网络协议设计原则和安全性问题，如数据加密、身份验证等。希望这些信息对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值