西魏陶渊明
西魏陶渊明

第04篇:手写JavaRPC框架之搞定网络通信

第04篇:手写JavaRPC框架之搞定网络通信_第1张图片

作者: 西魏陶渊明

博客: https://blog.springlearn.cn/

天下代码一大抄, 抄来抄去有提高, 看你会抄不会抄！

第04篇:手写JavaRPC框架之搞定网络通信_第2张图片

一、前言

  • 听说你Sql写的很溜，那么你知道服务端的Sql是如何被传输到SQL服务器执行的吗?
  • 听说你10分钟能写两个接口，那你知道数据是如何在两个系统中通讯的吗?
  • 听说你微服务玩的很熟练,那你知道微服务的基础是什么吗?

可以这样说，我们写的任何系统都离不开通讯，离不开网络编程，就没有现在我们发达的互联网世界。就没有什么分布式，没有什么微服务。所以由此可见网络编程是非常基础的知识。

但是我们思考下，有多少同学真正使用过Java网络通信的API了呢? 相信百分之80的小伙伴可能都没用过? 为什么呢? 因为我们站在巨人的肩膀上, 底层的代码都被层层的封装起来了,为了使我们能专注于业务的开发。这虽然提高了我们的开发效率。但是呢? 从另一个方面讲,他不利于我们的技术成长,使我们只会用，而不去思考为什么这么用。逐渐沦为CRUD Body。

个人如果想成长，想打破这种现状, 那么网络通信是一定要掌握的，当你掌握了这些，才算掌握了一点核心技术。当你掌握了这些，才能收获一些不一样的东西，看问题的维度又会有所提升。

本系列文章, 我们会一起来写RPC框架,而网络通讯是必要要掌握的知识,如果说以前你不懂,那么没关系跟着小编来Coding。我们一起来从0到1搭建一个网络通信层,然后以此为基础实现一个Java RPC框架吧。

二、目标

2.1 目标介绍

第04篇:手写JavaRPC框架之搞定网络通信_第3张图片

本篇文章是我们的第四篇，内容主要是实现网络通讯。通信层框架主要使用的是Netty进行实现, 说到Netty可能很多同学都没有用过。而要想实现通讯Netty就必须要知道，所以本篇内容篇幅较多。

  • 第一个目标,快速学习Netty的架构,掌握Netty 核心的API,最终唯我所用。
  • 第二个目标,使用Netty完成我们的通信层。

内容非常的硬核,难度指数比较大,也主要是偏向于实战。请专注学习,内容中如果有差错,欢迎提出。小编会积极回复,并改正。

三、Netty API 学习

第04篇:手写JavaRPC框架之搞定网络通信_第4张图片

前面第三篇我们学习了搞定序列化,在上一篇中我们介绍了这幅图,序列化就是将数据转换成二进制数据,在网络管道中传输。今天开头还是这一张图, 不过今天要说的不在是里面的数据,而是要研究下如何来构建一个通信的管道。本篇文章我们要利用Netty搭建一个网络管道。

第04篇:手写JavaRPC框架之搞定网络通信_第5张图片

这张图是对第一张图的一个细化，可以看到在这个管道的里面有一个双向的数据流【双工】。

客服端向服务端发送数据，服务端也可以同时向客户端发送数据。这个过程叫做全双工。为什么呢? 因为这个管道是TCP管道。我们所知道的Dubbo也是在此基础上实现的。所以说dubbo和http是平级的关系。

  • 一个inbound入栈方向，负责将二进制数据转换成Java对象
  • 一个outbound出库方向，负责将Java对象转换成二进制对象

3.1 ChannelPipeline 网络管道

上面的那个管道在Netty中就是 ChannelPipeline, ChannelPipeline 是Netty 中一个非常重要的组件,我们说的管道,就可以理解成是这个类，在这个管道中有两个方向的流向。如下

  • ChannelInboundHandler 入栈
  • ChannelOutboundHandler 出栈

只有管道还不行，要对管道中流动的数据进行处理。怎么来处理呢? 就是 ChannelHandler

3.2 ChannelHandler 管道处理器

ChannelHandle 通道处理器是最顶层接口, ChannelHandler 和 ChannelPipeline 的关系,好比这张图。

ChannelPipeline 相当于是管道,而 ChannelHandler 相当于管道中的每个拦路虎, 通过对数据的拦截,然后进行处理。下面这张图比较形象。

第04篇:手写JavaRPC框架之搞定网络通信_第6张图片

Netty 要想学的好, ChannelHandler 学习不能少,下面是 Netty 中 ChannelHandler 的类关系图。想要处理数据只用继承这其中的一些类就可以了。

第04篇:手写JavaRPC框架之搞定网络通信_第7张图片

请记住这张图,我们下面会利用这些管道处理器来实现我们的网络通信。

3.3 入栈管道解码器

编码器本质上就是一个 ChannelHandler, 所以上图我们也能看出来它是实现了 ChannelHandler的。

二进制数据转换成Java对象就要我们来搞一个入栈的解码器,通过上面的图我们知道Netty给我们提供了一个
入栈方向的类。ByteToMessageDecoder。那么我们就先实现他,直接看代码。

/**
 * 请求解码器负责将二进制数据转换成能处理的协议
 * 个人博客：https://java.springlearn.cn
 * 公众号：西魏陶渊明  ｛关注获取学习源码｝
 */
@Slf4j
public abstract class ChannelDecoder extends ByteToMessageDecoder {

    /**
     * 解码方法
     *
     * @param ctx 通道上下文信息
     * @param in  网络传过来的信息(注意粘包和拆包问题)
     * @param out in中的数据转换成对象调用out.add方法
     * @throws Exception 未知异常
     */
    @Override
    public void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception {
        doDecode(ctx, in, out);
    }


    /**
     * 解码方法
     *
     * @param ctx 通道上下文信息
     * @param in  网络传过来的信息(注意粘包和拆包问题)
     * @param out in中的数据转换成对象调用out.add方法
     * @throws Exception 未知异常
     */
    protected abstract void doDecode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception;
}
 
  
     
   
  •  
    doDecode 方法,通过读取ByteBuf中数据,然后经过的规则处理,就是协议处理,然后反序列化成Java对象,然后调用out.add()。
     
    •  
   
  •  
    这个规则处理，就是协议，我们在本系列文章的第二篇,就说了我们的协议是什么,如下这张图。那么我们就按照这个规则来解析数据吧。
     
    •  
  
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第8张图片
 
  
     
   
  • 实际上这里我们还要面对黏包和拆包的问题。什么是黏包和拆包呢？
    •  
  
 
  
3.4 黏包和拆包及解决方案
 
  
我们举一个例子,前两天某某国前首相安老三,遇到刺客了。这时候你很悲伤想发一个说说: 只要人没事就好。
 
  
拆包:
 
  
只要人没事就好 = 只要人没 + 事就好。
 第04篇:手写JavaRPC框架之搞定网络通信_第9张图片
 
  
就是形容一条完整的数据报文,因为某些原因,数据被分成多段进行传输了,当你读取数据的时候,读到的不是完整的数据，而是一半的数据。此时意思就比较尴尬了。只要人没，事就好 。
 
  
黏包:
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第10张图片
 
  
两条报文,连在一起发送了。导致了意思大变样。
 
  
就是数据都在网络管道中传输，但是我们服务定位每个报文的长度，导致了读取的数据就是混乱的。
 
  
那么拆包和黏包的问题我们都知道了,下面直接说解决方案吧。在Netty中有如下解决方案。
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第11张图片
 
  
     
   
  1. LineBasedFrameDecoder
    2.  
  
 
  
遇到了换行符，就当做是一条完整的消息
 
  
    @Test
    @DisplayName("使用换行符分隔符")
    void lineBasedFrameDecoder() {
        int maxLength = 100;
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        buffer.writeBytes("hello world\nhello\nworld\n".getBytes(StandardCharsets.UTF_8));
        EmbeddedChannel channel = new EmbeddedChannel(new LoggingHandler(LogLevel.DEBUG),
                new LineBasedFrameDecoder(maxLength),
                new ChannelInboundHandlerAdapter() {
                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                        ByteBuf buf = ((ByteBuf) msg);
                        String content = buf.toString(StandardCharsets.UTF_8);
                        System.out.println(content);
                    }
                });
//        hello world
//        hello 
//        world
        channel.writeInbound(ByteBufAllocator.DEFAULT.buffer().writeBytes(buffer));
    }

 
  
     
   
  1. DelimiterBasedFrameDecoder
    2.  
  
 
  
遇到了分隔符，就当做是一条完整的消息,分隔符可以自定义。我们可以指定多个分隔符,如下示例。
 
  
    @Test
    @DisplayName("自定义换行符分隔符")
    void delimiterBasedFrameDecoder() {
        int maxLength = 100;
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        buffer.writeBytes("hello world\nhello\rworld\\".getBytes(StandardCharsets.UTF_8));
        ByteBuf delimeter1 = Unpooled.buffer().writeBytes("\n".getBytes(StandardCharsets.UTF_8));
        ByteBuf delimeter2 = Unpooled.buffer().writeBytes("\r".getBytes(StandardCharsets.UTF_8));
        ByteBuf delimeter3 = Unpooled.buffer().writeBytes("\\".getBytes(StandardCharsets.UTF_8));
        EmbeddedChannel channel = new EmbeddedChannel(new LoggingHandler(LogLevel.DEBUG),
                new DelimiterBasedFrameDecoder(maxLength, delimeter1, delimeter2, delimeter3),
                new ChannelInboundHandlerAdapter() {
                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                        ByteBuf buf = ((ByteBuf) msg);
                        String content = buf.toString(StandardCharsets.UTF_8);
                        System.out.println(content);
                    }
                });
//        hello world
//        hello
//        world
        channel.writeInbound(ByteBufAllocator.DEFAULT.buffer().writeBytes(buffer));
    }

 
  
     
   
  1. FixedLengthFrameDecoder
    2.  
  
 
  
固定长度对消息进行拆分
 
  
    @Test
    @DisplayName("固定长度进行拆解")
    void fixedLengthFrameDecoder() {
        //这里每条消息设置的固定长度是5
        EmbeddedChannel channel = new EmbeddedChannel(new LoggingHandler(LogLevel.DEBUG), new FixedLengthFrameDecoder(5),
                new ChannelInboundHandlerAdapter() {
                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                        ByteBuf buf = ((ByteBuf) msg);
                        String content = buf.toString(StandardCharsets.UTF_8);
                        System.out.println(content);
                    }
                });
//        hello
//        world
//        welco
        channel.writeInbound(ByteBufAllocator.DEFAULT.buffer().writeBytes("helloworldwelcome".getBytes(StandardCharsets.UTF_8)));
    }

 
  
     
   
  1. LengthFieldBasedFrameDecoder
    2.  
  
 
  
消息分为两部分，一部分为消息头部，一部分为实际的消息体。其中消息头部是固定长度的，消息体是可变的，且消息头部一般会包含一个Length字段。
 
  
    @Test
    @DisplayName("动态获取长度报文")
    void lengthFieldBasedFrameDecoder() {
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        byte[] bytes = "hello world".getBytes(StandardCharsets.UTF_8);
        // 11
        System.out.println(bytes.length);
        // 4字节
        buffer.writeInt(bytes.length);
        // 真正的数据
        buffer.writeBytes(bytes);
        // 最大包长100字节
        int maxFrameLength = 100;
        // 从0开始,说明开头就是长度
        int lengthFieldOffset = 0;
        // 0 说明, 报文是有长度+真实数据组成的,没有其他的东西
        int lengthAdjustment = 0;
        // 跳过长度的字节，因为是int,所以是4字节
        int initialBytesToStrip = 4;
        EmbeddedChannel channel = new EmbeddedChannel(new LoggingHandler(LogLevel.DEBUG),
                new LengthFieldBasedFrameDecoder(maxFrameLength, lengthFieldOffset, 4, lengthAdjustment, initialBytesToStrip),
                new ChannelInboundHandlerAdapter() {
                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                        ByteBuf buf = ((ByteBuf) msg);
                        String content = buf.toString(StandardCharsets.UTF_8);
                        System.out.println(content);
                    }
                });
        channel.writeInbound(ByteBufAllocator.DEFAULT.buffer().writeBytes(buffer));
    }

 
  
好了，其实知道了问题产生的原因和已有的解决方案,我们也可以自己重新实现一个拆包和解包的方案,本篇文章我们就会自己来实现一个,具体的思路就是如下。
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第12张图片
 
  
看起来思路是不是很简单? 底层的API可不简单哦,记得自己看代码,建议拉下来自己走走。
 
  
3.5 入栈管道处理器
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第13张图片
 二进制数据经过前面的解码器,就会转换成Object对象。此时我们下一个处理器就可以直接处理这个Object对象了。此时我们可以来继承 SimpleChannelInboundHandler。自定义一个泛型。如下示例。我们演示下二进制数据转Java对象,并传给我们的业务处理器。
 
  
     
   
  • fillProtocol 首先我们按照我们定义的规则来，生成二进制数据流。
    •  
   
  • 然后解析成Java对象,并传给我们的处理器。
    •  
  
 
  
  /**
   * 请求解码器负责将二进制数据转换成能处理的协议
   * 虫洞栈：https://java.springlearn.cn
   * 公众号：西魏陶渊明  ｛关注获取学习源码｝
   */
  private ByteBuf fillProtocol() throws Exception {
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        RpcRequest rpcRequest = new RpcRequest();
        //1. 获取协议类型(1个字节)
        buffer.writeByte(rpcRequest.getProtocolType());
        //2. 获取序列化类型(1个字节)
        buffer.writeByte(rpcRequest.getSerializationType());
        //3. 根据序列化类型找到数据转换器生成二进制数据
        Serializer serializer = SerializeEnum.
                ofByType(rpcRequest.getSerializationType())
                .getSerialize().newInstance();
        byte[] data = serializer.serialize(rpcRequest);
        //4. 写入报文长度(4个字节)
        buffer.writeInt(data.length);
        //5. 写入报文内容(数组)
        buffer.writeBytes(data);
        return buffer;
    }

    @Test
    @DisplayName("SimpleChannelInboundHandler自动匹配支持的Java对象")
    public void test() throws Exception {
        // 根据自定义协议生成二进制数据流
        ByteBuf byteBuf = fillProtocol();
        EmbeddedChannel channel = new EmbeddedChannel(new LoggingHandler(LogLevel.DEBUG),
                new ChannelInitializer<EmbeddedChannel>() {
                    @Override
                    protected void initChannel(EmbeddedChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast("a handler", new MojitoChannelDecoder("mojito"));
                        pipeline.addLast("b handler",// 自定义一个String类型的
                                new SimpleChannelInboundHandler<RpcRequest>() {
                                    @Override
                                    protected void channelRead0(ChannelHandlerContext ctx, RpcRequest msg) throws Exception {
                                        System.out.println("RpcRequest:" + msg);
                                        // 向下传播
                                        ctx.fireChannelRead(msg);
                                    }
                                });
                        pipeline.addLast("c handler", new SimpleChannelInboundHandler<Integer>() {
                            @Override
                            protected void channelRead0(ChannelHandlerContext ctx, Integer msg) throws Exception {
                                System.out.println("Integer:" + msg);
                            }
                        });
                    }
                });
        channel.writeInbound(ByteBufAllocator.DEFAULT.buffer().writeBytes(byteBuf));
    }

 
  
     
   
  • b handler 的泛型是RpcRequest,二进制数据经过MojitoChannelDecoder将数据转换成RpcRequest对象,此时就会进到b handler。
    •  
   
  • 而在b handler中我们继续调用方法向下传播数据。ctx.fireChannelRead(msg)。会发现c handler并没有执行,为什么呢? 因为SimpleChannelInboundHandler有一个特性,就是只有数据类型为自己定义的泛型的时候才会进入。
    •  
  
 
  
如下源码也比较简单，这个特性我们可以抄一下, 可以用到我们需要的地方。
 
  
 TypeParameterMatcher.find(this, SimpleChannelInboundHandler.class, "I");
 
  
读取泛型类型。
 
  
public abstract class SimpleChannelInboundHandler<I> extends ChannelInboundHandlerAdapter {

     private final TypeParameterMatcher matcher;
 
     protected SimpleChannelInboundHandler(boolean autoRelease) {
        matcher = TypeParameterMatcher.find(this, SimpleChannelInboundHandler.class, "I");
        this.autoRelease = autoRelease;
    }
 public boolean acceptInboundMessage(Object msg) throws Exception {
        return matcher.match(msg);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        boolean release = true;
        try {
            if (acceptInboundMessage(msg)) {
                @SuppressWarnings("unchecked")
                I imsg = (I) msg;
                channelRead0(ctx, imsg);
            } else {
                release = false;
                ctx.fireChannelRead(msg);
            }
        } finally {
            if (autoRelease && release) {
                ReferenceCountUtil.release(msg);
            }
        }
    }

}

 
  
好了，到这里我们的入栈流程就说完了。下面我们说出栈的流程。
 
  
3.6 出栈管道处理器
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第14张图片
 
  
通过前面我们对 ChannelHandler 的了解,如果我们要写出栈的处理器,其实就是要继承 ChannelOutboundHandlerAdapter 。以下面这个例子,我们写一个 RpcResponse 对象。
 
  
     
   
  • a handler 是编码器,负责将 RpcResponse 对象转成二进制数据
    •  
   
  • b handler 是出栈处理器, 而里面的Object类型的msg究竟是二进制数据呢？ 还是 RpcResponse呢? 这个就要看出栈执行器的位置了。
    •  
  
 
  
这个问题,后面在3.7就能找到答案。
 
  
    @Test
    @DisplayName("出栈处理器")
    public void testOutbound() throws Exception {
        EmbeddedChannel channel = new EmbeddedChannel(new LoggingHandler(LogLevel.DEBUG),
                new ChannelInitializer<EmbeddedChannel>() {
                    @Override
                    protected void initChannel(EmbeddedChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast("a handler", new MojitoChannelEncoder("mojito"));
                        pipeline.addLast("b handler", new ChannelOutboundHandlerAdapter() {
                            @Override
                            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                                System.out.println("Write:" + msg);
                                super.write(ctx, msg, promise);
                            }
                        });
                    }
                });
        RpcResponse rpcResponse = new RpcResponse();
        channel.writeOutbound(rpcResponse);
    }

 
  
3.7 处理器顺序
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第15张图片
 
  
  ChannelPipeline p = ...;
  p.addLast("1", new InboundHandlerA());
  p.addLast("2", new InboundHandlerB());
  p.addLast("3", new OutboundHandlerA());
  p.addLast("4", new OutboundHandlerB());
  p.addLast("5", new InboundOutboundHandlerX());

 
  
     
   
  • 入栈: 1 -> 2 -> 5
    •  
   
  • 出栈: 5 -> 4 -> 3
    •  
  
 
  
所以由此得出,3.5 Write的地方,会打印 RpcResponse 对象。
 
  
好了,到这里Netty的核心API其实就学习完了,了解了这些就算入门了。下面我们看如何来组装这些API吧。
 
  
3.8 服务端引导类
 
  
通过前面的学习,我们已经知道在Netty 中如何将二进制数据转换成Java对象,并进行业务处理,然后在将业务数据通过出栈处理器器转换成二进制数据返回了。那么我们现在来看下如何用Netty构建一个服务端吧。
 直接上代码。
 
  
    /**
     * @author liuxin
     * 个人博客：https://java.springlearn.cn
     * 公众号：西魏陶渊明  ｛关注获取学习源码｝
     * 2022/8/11 23:12
     */
    @Test
    @DisplayName("构建一个服务端")
    public void testServer() throws Exception {
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        // io 线程一个进行轮训即可
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1, new NamedThreadFactory("boss"));
        // 业务处理线程组, CPU线程数 + 1 即可: (同一个核心同一时刻只能执行一个任务,所以创建多了也没用,建议给N+1个)
        NioEventLoopGroup workGroup = new NioEventLoopGroup(
                Runtime.getRuntime().availableProcessors() + 1, new NamedThreadFactory("work"));
        serverBootstrap.group(bossGroup, workGroup)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        // 我们的管道信息信息就在这里
                        ChannelPipeline pipeline = ch.pipeline();

                    }
                }).channel(OSinfo.isLinux() ? EpollServerSocketChannel.class : NioServerSocketChannel.class);
        ChannelFuture sync = serverBootstrap.bind(8080).sync();
        sync.addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                System.out.println("端口绑定成功");
            } else {
                System.out.println("端口绑定失败:" + future.cause().getCause());
            }
        });
        Channel channel = sync.channel();
        // 添加一个关闭时间监听器
        channel.closeFuture().addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                System.out.println("服务关闭成功");
            } else {
                System.out.println("服务关闭失败:" + future.cause().getCause());
            }
        });
        channel.close();
    }

 
  
3.9 客户端引导类
 
  
这里我们为了测试,我们先构建一个服务端,然后构建一个客户端然后进行访问。我们看服务端的输出。
 
  
     
   
  • 构建服务端打印请求连接和释放连接事件
    •  
  
 
  
    /**
     * 请求解码器负责将二进制数据转换成能处理的协议
     * 虫洞栈：https://java.springlearn.cn
     * 公众号：西魏陶渊明  ｛关注获取学习源码｝
     */
    @Test
    @DisplayName("构建一个服务端")
    public void testServer() throws Exception {
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        // io 线程一个进行轮训即可
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1, new NamedThreadFactory("boss"));
        // 业务处理线程组, CPU线程数 + 1 即可: (同一个核心同一时刻只能执行一个任务,所以创建多了也没用,建议给N+1个)
        NioEventLoopGroup workGroup = new NioEventLoopGroup(
                Runtime.getRuntime().availableProcessors() + 1, new NamedThreadFactory("work"));
        serverBootstrap.group(bossGroup, workGroup)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        // 设置我们的管道信息
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast(new ChannelInboundHandlerAdapter() {
                            @Override
                            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                Channel channel = ctx.channel();
                                SocketAddress socketAddress = channel.remoteAddress();
                                System.out.println("收到了一个链接:" + socketAddress);
                                ctx.fireChannelActive();
                            }

                            @Override
                            public void channelInactive(ChannelHandlerContext ctx) throws Exception {
                                Channel channel = ctx.channel();
                                SocketAddress socketAddress = channel.remoteAddress();
                                System.out.println(socketAddress + ":关闭连接");
                            }
                        });
                    }
                }).channel(OSinfo.isLinux() ? EpollServerSocketChannel.class : NioServerSocketChannel.class);
        ChannelFuture sync = serverBootstrap.bind(8080).sync();
        sync.addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                System.out.println("端口绑定成功");
            } else {
                System.out.println("端口绑定失败:" + future.cause().getCause());
            }
        });
        Channel channel = sync.channel();
        // 添加一个关闭时间监听器
        channel.closeFuture().addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                System.out.println("服务关闭成功");
            } else {
                System.out.println("服务关闭失败:" + future.cause().getCause());
            }
        }).sync();
        channel.close();
    }

 
  
     
   
  • 构建客户端
    •  
  
 
  
    @Test
    public void testClient() throws Exception {
        NioEventLoopGroup workGroup = new NioEventLoopGroup(
                Runtime.getRuntime().availableProcessors() + 1, new NamedThreadFactory("work"));
        Bootstrap clientBootstrap = new Bootstrap();
        clientBootstrap.group(workGroup);
        clientBootstrap.channel(NioSocketChannel.class);
        clientBootstrap.option(ChannelOption.TCP_NODELAY, false);
        clientBootstrap.handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
                // 设置我们的管道
                ChannelPipeline pipeline = ch.pipeline();
                // 客户端要将我们发出的Java对象转换成二进制对象输入
                // 客户端要将服务端发送的二进制对象转换成Java对象
            }
        });
        ChannelFuture channelFuture = clientBootstrap.connect("127.0.0.1", 8080).sync();
        channelFuture.channel().write("HelloWord");
    }

 
  
服务端控制台输出:
 
  
     
   
  • 端口绑定成功
    •  
   
  • 收到了一个链接:/127.0.0.1:55732
    •  
   
  • /127.0.0.1:55732:关闭连接
    •  
  
 
  
3.10 Netty 学习总结
 
  
好了，我们一口气吧 Netty 的API都学习了,知识点有点多,大家可以看着图来理解。这里学习Netty是因为我们要用Netty来构建一个网络通道。用于我们开发RPC框架，这点知识已经够用了。但是需要注意的是 Netty 并不仅仅只有这些知识点。Netty 为什么这么快? 吞吐量这么高? 值得我们学习的知识点还有很多。这个后面我们单独再来说,本篇文章我们就了解这么多就够用了。下面我们终于可以开始自己的Coding了。
 
  
四、通信层搭建
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第16张图片
 
  
     
   
  • 第01篇:手写JavaRPC框架之思路分析
    •  
   
  • 第02篇:手写JavaRPC框架之设计思路
    •  
   
  • 第03篇: 手写JavaRPC框架之搞定序列化
    •  
  
 
  
通过前三篇的学习及上面对Netty的学习,相信上图中关于底层通信的所有知识点都已经了解了吧。那么下面就开始编程了。来一步一步完成我们的通信层。
 
  
4.1 工程结构
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第17张图片
 
  
4.2 架构设计
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第18张图片
 
  
所谓的架构其实就会对于Netty 管道中的处理逻辑和分层。
 
  
     
   
  • Config API 其实就是我们的Fluent风格的API
    •  
   
  • Business 就是我们提供给开发者用来实现业务的接口
    •  
   
  • Model 是我们原型开发者自定义自己的数据传输模型,前提是要集成 ProtocolHeader
    •  
   
  • Exchange 用于屏蔽Netty原生众多的API,通过封装只暴露我们需要感知的API
    •  
   
  • Codec 提供自定义的解码器和编码器,同时也能支持HTTP的协议
    •  
   
  • Serialize 底层的序列化实现
    •  
  
 
  
4.3 服务端
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第19张图片
 
  
     
   
  1. 首先我们定义出 Server 接口,为了尽量让职责单一。我们将配置方法和核心的能力分开，又定义了
     提供配置的 ConfigurableServer。 这块代码我们就是抄的Spring的ApplicationContext的设计。设计的好处是,接口隔离原则,即一个类与其他类保留最少的关系。这样说可能还不好理解。我们思考下
     Server集成了ConfigurableServer。假如说我们把所有的接口定义都放在Server中。当我们要把配置的信息,暴露给外面的时候,只能将Server给提供出去,但是Server中有那么多的非配置的方法,是不是都被外部所感知到了呢? 解决办法就是将接口细化, 给外部只提供ConfigurableServer。这样外部就看不到Server中所有的方法,就不会被困扰。
    2.  
  
 
  
  // 给外面提供的接口能力太大了,他不关心的提供出来就是困扰。
  public void customerConfig(Server server);
  // 提供的都是我想要的,一起都是刚刚好。
  public void customerConfig(ConfigurableServer confServer);

 
  
     
   
  1.  
    目前我们是使用Netty通信框架进行的实现,但是为了以后可以支持其他的通信框架,我们定义了抽象模板类 AbstractServer。在模板类型,只定义统一的创建服务端的流程。而具体的细节,交给了抽象方法。如果说后面我们不使用Netty来,我们的改动也是最小的。
     
    2.  
   
  2.  
    NettyServer 继承了 AbstractServer 实现了其定义的抽象方法,具体的负责创建服务。
     
    3.  
  
 
  
代码如下,更多细节可以到下载代码学习。
 
  
public interface ConfigurableServer<T extends Server<?>> {

    /**
     * 给网络通道注册二进制处理协议
     *
     * @param protocol 协议
     */
    void registryProtocol(Protocol<? extends ProtocolHeader, ? extends ProtocolHeader> protocol);

    /**
     * 注册钩子程序
     */
    void registryHooks(Runnable hookTask);

    /**
     * 协议信息
     *
     * @return Protocol
     */
    Protocol<? extends ProtocolHeader, ? extends ProtocolHeader> getProtocol();

    /**
     * 这里我们提供一个Server初始化的方法,为什么呢?
     * 目前我们的服务端是使用NettyServer,我们也支持其他的通信框架。因为可能初始化方法不一样.
     * 所以我们将具体的实现作为一个泛型。让具体的实现来自己定义自己的初始化方法
     *
     * @param initializer 初始化接口
     */
    void initializer(ServerInitializer<T> initializer);
}

public interface Server<T extends Server<?>> extends ConfigurableServer<T> {

    /**
     * 启动服务
     *
     * @param port 服务端口号
     */
    void start(int port);

    /**
     * 非阻塞启动
     *
     * @param port 端口
     */
    void startAsync(int port);

    /**
     * 关闭服务
     */
    void close();

    /**
     * 服务器端口
     *
     * @return int
     */
    int getPort();

    /**
     * 是否运行中
     *
     * @return boolean
     */
    boolean isRun();

}

/**
 * @author liuxin
 * 2022/8/10 22:16
 */
public abstract class AbstractServer<T extends Server<?>> implements Server<T> {

    private ServerInitializer<T> serverInitializer;

    private Integer port;

    private final AtomicBoolean runningState = new AtomicBoolean(false);

    private Protocol<? extends ProtocolHeader, ? extends ProtocolHeader> protocol;

    @Override
    public void registryProtocol(Protocol<? extends ProtocolHeader, ? extends ProtocolHeader> protocol) {
        this.protocol = protocol;
    }

    @Override
    public void registryHooks(Runnable hookTask) {
        ThreadHookTools.addHook(new Thread(hookTask));
    }

    @Override
    public Protocol<? extends ProtocolHeader, ? extends ProtocolHeader> getProtocol() {
        return protocol;
    }

    @Override
    public void initializer(ServerInitializer<T> initializer) {
        this.serverInitializer = initializer;
    }

    @Override
    public ServerInitializer<T> getServerInitializer() {
        return serverInitializer;
    }

    @Override
    public void start(int port) {
        checked();
        activeAndCreateServer(() -> {
            this.port = port;
            doCreateServer(port, false);
        });
    }

    private void checked() {
        if (Objects.isNull(protocol)) {
            throw new RuntimeException("Protocol不能为空,请Server#registryProtocol");
        }
        if (Objects.isNull(serverInitializer)) {
            throw new RuntimeException("Protocol不能为空,请Server#initializer");
        }
    }

    private void activeAndCreateServer(LambdaExecute execute) {
        if (isRun()) {
            throw new RuntimeException("运行中");
        }
        if (runningState.compareAndSet(false, true)) {
            try {
                execute.execute();
            } catch (Throwable t) {
                runningState.compareAndSet(true, false);
            }
        }
    }

    private void closeAndDestroyServer(LambdaExecute execute) {
        if (isRun()) {
            if (runningState.compareAndSet(true, false)) {
                execute.execute();
            }
        }
    }

    @Override
    public void startAsync(int port) {
        activeAndCreateServer(() -> {
            this.port = port;
            doCreateServer(port, true);
        });
    }

    @Override
    public void close() {
        closeAndDestroyServer(this::doDestroyServer);
    }

    @Override
    public int getPort() {
        return this.port;
    }

    @Override
    public boolean isRun() {
        return runningState.get();
    }

    public abstract void doCreateServer(int port, boolean async);

    public abstract void doDestroyServer();
}

@Slf4j
public class NettyServer extends AbstractServer<NettyServer> {

    private final ServerBootstrap serverBootstrap = new ServerBootstrap();

    private Channel serverChannel;

    private EventLoopGroup bossGroup;

    private EventLoopGroup workerGroup;

    private static final int DEFAULT_EVENT_THREADS = Math.min(Runtime.getRuntime().availableProcessors() + 1, 32);

    public ServerBootstrap getServerBootstrap() {
        return this.serverBootstrap;
    }

    @Override
    @SneakyThrows
    public void doCreateServer(int port, boolean async) {
        // 1. io线程数 = cpu * 2
        bossGroup = new NioEventLoopGroup(1, new NamedThreadFactory("mojito-boss", true));
        // 2. 业务线程数 = cpu + 1
        workerGroup = new NioEventLoopGroup(DEFAULT_EVENT_THREADS, new NamedThreadFactory("mojito-work", true));
        serverBootstrap.group(bossGroup, workerGroup)
                .childOption(ChannelOption.TCP_NODELAY, true)
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                .option(ChannelOption.SO_BACKLOG, 128)
                .handler(new LoggingHandler(LogLevel.INFO))
                .channel(OSinfo.isLinux() ? EpollServerSocketChannel.class : NioServerSocketChannel.class)
                .localAddress(port).option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000);
        getServerInitializer().initializer(this);
        // 3. 阻塞绑定端口
        ChannelFuture bindFuture = serverBootstrap.bind().addListener((ChannelFutureListener) channelFuture -> {
            if (channelFuture.isSuccess()) {
                log.info(Banner.print("麻烦给我的爱人来一杯Mojito,我喜欢阅读她微醺时的眼眸！", Ansi.Color.RED));
                log.info("Mojito启动成功,端口号:" + port);
            } else {
                Throwable cause = channelFuture.cause();
                throw new RuntimeException(cause);
            }
        }).sync();
        serverChannel = bindFuture.channel();
        if (async) {
            log.info("异步服务启动成功");
        } else {
            serverChannel.closeFuture().sync();
            log.info("阻塞服务启动成功");
        }
    }

    @Override
    public void doDestroyServer() {
        workerGroup.shutdownGracefully();
        bossGroup.shutdownGracefully();
        serverChannel.close();
    }
    
}


 
  
4.4 客户端
 
  
第04篇:手写JavaRPC框架之搞定网络通信_第20张图片
 
  
服务端的设计和客户端的设计是一样的,依赖抽象不依赖细节。架构设计只是定义好流程,具体是什么框架来实现底层的通信,就交给最底层的细节。
 
  
     
   
  • 客户端有几个核心的地方
    •  
  
 
  
     
   
  1. 连接服务器
    2.  
   
  2. 发送数据(同步&异步)
    3.  
   
  3. 断线重连(放在优化的时候讲)
    4.  
   
  4. 异步转同步问题
    5.  
  
 
  

/**
 * @author liuxin
 * 2022/8/5 23:12
 */
public interface ConfigurableClient<REQ extends ProtocolHeader, RES extends ProtocolHeader, T extends Client<REQ, RES>> {

    /**
     * 给网络通道注册二进制处理协议
     *
     * @param protocol 协议
     */
    void registryProtocol(Protocol<REQ, RES> protocol);

    /**
     * 协议信息
     *
     * @return Protocol
     */
    Protocol<REQ, RES> getProtocol();

    /**
     * 注册钩子程序
     */
    void registryHooks(Runnable hookTask);

    /**
     * 这里我们提供一个Server初始化的方法,为什么呢?
     * 目前我们的服务端是使用NettyServer,我们也支持其他的通信框架。因为可能初始化方法不一样.
     * 所以我们将具体的实现作为一个泛型。让具体的实现来自己定义自己的初始化方法
     *
     * @param initializer 初始化接口
     */
    void initializer(ClientInitializer initializer);

    /**
     * 客户端初始化扩展
     *
     * @return ClientInitializer
     */
    ClientInitializer<Client<REQ, RES>> getClientInitializer();

}

/**
 * @author liuxin
 * 个人博客：https://java.springlearn.cn
 * 公众号：西魏陶渊明  ｛关注获取学习源码｝
 * 2022/8/5 23:12
 */
public interface Client<REQ extends ProtocolHeader, RES extends ProtocolHeader> extends ConfigurableClient<REQ, RES, Client<REQ, RES>> {


    /**
     * 建立连接
     *
     * @param host 连接地址
     * @param port 连接端口
     */
    void connect(String host, Integer port);

    /**
     * 发送消息
     *
     * @param req 请求体
     * @return 异步结果
     */
    MojitoFuture<RES> send(REQ req);

    /**
     * 关闭连接
     */
    void close();


    /**
     * 是否连接
     *
     * @return boolean
     */
    boolean isRun();

    /**
     * 是否连接
     *
     * @return boolean
     */
    boolean isConnected();


}
/**
 * @author liuxin
 * 个人博客：https://java.springlearn.cn
 * 公众号：西魏陶渊明  ｛关注获取学习源码｝
 * 2022/8/5 23:12
 */
public abstract class AbstractClient<REQ extends ProtocolHeader, RES extends ProtocolHeader> implements Client<REQ, RES> {


    /**
     * 将要连接的远程地址
     */
    private String remoteHost;

    /**
     * 将要连接的远程端口
     */
    private int remotePort;

    private Protocol<REQ, RES> protocol;

    private ClientInitializer<Client<REQ, RES>> clientInitializer;

    private final AtomicBoolean running = new AtomicBoolean(false);

    @Override
    public void connect(String host, Integer port) {
        if (!running.get()) {
            this.remoteHost = host;
            this.remotePort = port;
        }
        try {
            if (running.compareAndSet(false, true)) {
                doConnect();
            }
        } catch (Throwable t) {
            t.printStackTrace();
            running.compareAndSet(true, false);
        }
    }

    @Override
    public MojitoFuture<RES> send(REQ req) {
        return doSend(req);
    }

    @Override
    public void close() {
        doClose();
    }

    public int getRemotePort() {
        return remotePort;
    }

    public String getRemoteHost() {
        return remoteHost;
    }

    @Override
    public Protocol<REQ, RES> getProtocol() {
        return this.protocol;
    }


    @Override
    public void registryProtocol(Protocol<REQ, RES> protocol) {
        this.protocol = protocol;
    }

    @Override
    public void registryHooks(Runnable hookTask) {
        ThreadHookTools.addHook(new Thread(hookTask));
    }

    @Override
    public void initializer(ClientInitializer initializer) {
        this.clientInitializer = initializer;
    }

    @Override
    public boolean isRun() {
        return running.get();
    }

    @Override
    public ClientInitializer<Client<REQ, RES>> getClientInitializer() {
        return clientInitializer;
    }

    public abstract void doConnect();

    public abstract void doClose();

    public abstract MojitoFuture<RES> doSend(REQ req);
}

/**
 * @author liuxin
 * 个人博客：https://java.springlearn.cn
 * 公众号：西魏陶渊明  ｛关注获取学习源码｝
 * 2022/8/5 23:12
 */
@Slf4j
public class NettyClient<REQ extends ProtocolHeader, RES extends ProtocolHeader> extends AbstractClient<REQ, RES> {

    private final Bootstrap clientBootstrap = new Bootstrap();

    private final EventLoopGroup workerGroup = new NioEventLoopGroup();

    private DefaultEnhanceChannel enhanceChannel;

    @Override
    @SneakyThrows
    public void doConnect() {
        clientBootstrap.group(workerGroup);
        clientBootstrap.channel(NioSocketChannel.class);
        clientBootstrap.option(ChannelOption.TCP_NODELAY, false);
        getClientInitializer().initializer(this);
        ChannelFuture channelFuture = clientBootstrap.connect(getRemoteHost(), getRemotePort()).sync();
        enhanceChannel = DefaultEnhanceChannel.getOrAddChannel(channelFuture.channel());
    }

    public Bootstrap getClientBootstrap() {
        return clientBootstrap;
    }

    @Override
    public void doClose() {
        workerGroup.shutdownGracefully();
        enhanceChannel.disconnected();
        log.info("Client 关闭成功");
    }

    @Override
    public MojitoFuture<RES> doSend(REQ req) {
        // 这里我们也设置,断线重连,后面优化
        return getProtocol().getClientPromiseHandler().sendAsync(enhanceChannel, req);
    }

    @Override
    public boolean isConnected() {
        return Objects.nonNull(enhanceChannel) && enhanceChannel.isConnected();
    }


}


 
  
4.5 异步转同步
 
  
socket通信发送数据,什么时候回复都可以。甚至可以客户端一直发，而服务端不进行回复。而我们的RPC框架更像一问一答,发送请求后,需要立马就收到回复。每个请求都要对应一个响应,这就需要我们进行特殊的设计来完成,这样的需求。
 
  
我们的思路就是实现,Jdk的Future,并给他添加上监听器的功能。因为我们主要是学习,所以不要怕麻烦,不要怕重新造轮子。下面我们开始实现它。
 
  
mojito/mojito-net/src/main/java/cn/lxchinesszz/mojito/future on  master [!+?] 
➜ tree                 
.
├── MojitoFuture.java
├── Promise.java
└── listener
    ├── MojitoListener.java
    └── MojitoListeners.java


 
  
     
   
  • 定义接口 Promise。承诺,这个接口一定会告诉你成功或者失败。这样的设计Js上运用是最多的。
    •  
  
 
  
public interface Promise<V> {

    /**
     * 是否成功
     *
     * @return boolean
     */
    boolean isSuccess();

    /**
     * 设置成功表示
     *
     * @param data 数据
     */
    void setSuccess(V data);

    /**
     * 设置失败标识
     *
     * @param cause 异常
     */
    void setFailure(Throwable cause);

    /**
     * 添加监听器
     *
     * @param listener 监听器
     */
    void addListeners(MojitoListener<V> listener);
}

 
  
     
   
  • 实现核心方法
    •  
  
 
  
这里需要注意的就是多线程的可见性和多线程的原子性问题以及如何实现线程等待。如果这部分不太容易理解，建议可以先多了解点关于线程安全的知识点。然后回过头在来看。
 
  
     
   
  • Java并发编程之Condition条件锁
    •  
   
  • Java多线程编程之线程安全感
    •  
   
  • Java并发编程之原子操作
    •  
  
 
  
public class MojitoFuture<V> implements Promise<V>, Future<V> {

    /**
     * volatile 多线程保证可见性
     */
    private volatile V result;
    
     /**
     * AtomicReferenceFieldUpdater 多线程保证操作的原子性
     */
    @SuppressWarnings("rawtypes")
    private static final AtomicReferenceFieldUpdater<MojitoFuture, Object> RESULT_UPDATER =
            AtomicReferenceFieldUpdater.newUpdater(MojitoFuture.class, Object.class, "result");
            
    /**
     * 当前承诺的监听器
     */
    private final List<MojitoListener<V>> listeners = new ArrayList<>();

    /**
     * 是否被撤销了
     */
    private boolean cancelled = false;

    /**
     * 并发锁
     */
    private final ReentrantLock lock = new ReentrantLock();

    /**
     * get 阻塞条件,用于完成时候唤醒get阻塞线程
     */
    private final Condition condition = lock.newCondition();

    /**
     * get超时阻塞条件,,用于完成时候唤醒get阻塞线程
     */
    private final Condition timeoutCondition = lock.newCondition();
    
    /**
     * 原子操作
     *
     * @param objResult 数据
     * @return boolean
     */
    private boolean setValue0(Object objResult) {
        if (RESULT_UPDATER.compareAndSet(this, null, objResult) ||
                RESULT_UPDATER.compareAndSet(this, EMPTY, objResult)) {
            return true;
        }
        return false;
    }

    @Override
    public boolean isSuccess() {
        return isDone() && result != EMPTY;
    }

    @Override
    public void setSuccess(V data) {
        boolean updateSuccess;
        try {
            lock.lock();
            updateSuccess = setValue0(data);
            condition.signalAll();
            timeoutCondition.signalAll();
        } finally {
            lock.unlock();
        }
        if (updateSuccess) {
            for (MojitoListener<V> listener : listeners) {
                listener.onSuccess(data);
            }
        }
    }

    @Override
    public void setFailure(Throwable cause) {
        boolean updateSuccess;
        try {
            lock.lock();
            updateSuccess = setValue0(EMPTY);
            condition.signalAll();
            timeoutCondition.signalAll();
        } finally {
            lock.unlock();
        }
        if (updateSuccess) {
            for (MojitoListener<V> listener : listeners) {
                listener.onThrowable(cause);
            }
        }
    }


    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
        this.cancelled = mayInterruptIfRunning;
        return false;
    }

    @Override
    public boolean isCancelled() {
        return cancelled;
    }

    @Override
    public boolean isDone() {
        // 只要不等于空,说明就是有结果了,不管成功或者失败
        return result != null;
    }

    @Override
    public V get() throws InterruptedException, ExecutionException {
        lock.lock();
        try {
            if (Thread.currentThread().isInterrupted()) {
                throw new InterruptedException();
            } else {
                // 如果没有完成并且没有撤销
                if (!isDone() && !isCancelled()) {
                    // 释放线程,任务在这里阻塞,等待完成时候释放.
                    condition.await();
                }
            }
        } finally {
            lock.unlock();
        }
        return isSuccess() ? result : null;
    }

    @Override
    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        lock.lock();
        try {
            if (Thread.currentThread().isInterrupted()) {
                throw new InterruptedException();
            } else {
                // 如果没有完成并且没有撤销
                if (!isDone() && !isCancelled()) {
                    // 释放线程,任务在这里阻塞,等待完成时候释放.
                    boolean await = timeoutCondition.await(timeout, unit);
                    if (!await) {
                        throw new TimeoutException();
                    }
                }
            }
        } finally {
            lock.unlock();
        }
        return isSuccess() ? result : null;
    }

    @Override
    public void addListeners(MojitoListener<V> listener) {
        this.listeners.add(listener);
    }
}

 
  
4.6 Fluent API
 
  
好了,前面我们快速的学习了Netty的API,后面我们使用了Netty来实现了我们的底层通信能力。但是这里还是太复杂了,最后我们要为这些复杂的对象,设计一套简单的使用API。API的风格决定使用 Fluent API
 
  
 
   
fluent-API 是一种面向对象的 API，其设计主要基于方法链。
 这个概念由​Eric Evans​和​Martin Fowler​于 2005 年创建，旨在通过创建特定领域语言 ( DSL )来提高代码可读性。
 
  
 
  
在实践中，创建一个流畅的 API，就是不需要记住接下来的步骤或方法，一切都是那么的自然和连续,下一步的动作，就好像它是一个选项菜单,让我们的选择。
 
  
关键词: 自然连续，无需记住
 
  
这里面主要是对Java泛型的利用,主要实现在这里,基本都是泛型,所以要好好看。建议获取源码,运行走走。
 
  
mojito/mojito-net/src/main/java/cn/lxchinesszz/mojito/fluent on  master [»!?] 
➜ tree               
.
├── AbstractFactory.java
├── ConfigurableFactory.java
├── Factory.java
└── Mojito.java


 
  
下面我们来展示,来看下这个API,是否合乎你的心意呢?
 
  
     
   
  1. 服务端
    2.  
  
 
  
class MojitoTest{
    /**
     * @author liuxin
     * 个人博客：https://java.springlearn.cn
     * 公众号：西魏陶渊明  ｛关注获取学习源码｝
     * 2022/8/11 23:12
     */
    @Test
    @DisplayName("构建服务端【阻塞方式】")
    public void server() throws Exception {
        Server<?> server = Mojito.server(RpcRequest.class, RpcResponse.class)
                // 业务层,读取请求对象,返回结果
                .businessHandler((channelContext, request) -> new RpcResponse())
                .create();
        server.start(6666);
    }
    
    /**
     * @author liuxin
     * 个人博客：https://java.springlearn.cn
     * 公众号：西魏陶渊明  ｛关注获取学习源码｝
     * 2022/8/11 23:12
     */
    @Test
    @DisplayName("构建服务端【非阻塞方式】")
    public void serverAsync() throws Exception {
        Server<?> server = Mojito.server(RpcRequest.class, RpcResponse.class)
                // 业务层,读取请求对象,返回结果
                .businessHandler((channelContext, request) -> new RpcResponse())
                .create();
        server.startAsync(6666);
    }
}    

 
  
     
   
  1. 客户端
    2.  
  
 
  
支持同步和异步两种方式
 
  
   /**
     * @author liuxin
     * 个人博客：https://java.springlearn.cn
     * 公众号：西魏陶渊明  ｛关注获取学习源码｝
     * 2022/8/11 23:12
     */
    @Test
    @DisplayName("构建客户端【异步方式】")
    public void clientAsync() throws Exception {
        // 构建连接
        Client<RpcRequest, RpcResponse> client = Mojito.client(RpcRequest.class, RpcResponse.class)
                .connect("127.0.0.1", 6666);

        MojitoFuture<RpcResponse> sendFuture = client.sendAsync(new RpcRequest());
        sendFuture.addListeners(new MojitoListener<RpcResponse>() {
            @Override
            public void onSuccess(RpcResponse result) {
                System.out.println("收到结果:" + result);
            }

            @Override
            public void onThrowable(Throwable throwable) {
                System.err.println("处理失败:" + throwable.getMessage());
            }
        });
        Thread.currentThread().join();
    }

    /**
     * @author liuxin
     * 个人博客：https://java.springlearn.cn
     * 公众号：西魏陶渊明  ｛关注获取学习源码｝
     * 2022/8/11 23:12
     */
    @Test
    @DisplayName("构建客户端【同步方式】")
    public void clientSync() throws Exception{
        Client<RpcRequest, RpcResponse> client = Mojito.client(RpcRequest.class, RpcResponse.class)
                .connect("127.0.0.1", 6666);
        System.out.println(client.send(new RpcRequest()));
    }


 
  
     
   
  1. 启动演示
    2.  
  
 
  
当看到下面的Logo说明服务已经启动成功了。
 
  
 ___      ___     ______      ___  __  ___________  ______    
|"  \    /"  |   /    " \    |"  ||" \("     _   ")/    " \   
 \   \  //   |  // ____  \   ||  |||  |)__/  \\__/// ____  \  
 /\\  \/.    | /  /    ) :)  |:  ||:  |   \\_ /  /  /    ) :) 
|: \.        |(: (____/ //___|  / |.  |   |.  | (: (____/ //  
|.  \    /:  | \        //  :|_/ )/\  |\  \:  |  \        /   
|___|\__/|___|  \"_____/(_______/(__\_|_)  \__|   \"_____/   

 :: Mojito ::                                     
麻烦给我的爱人来一杯Mojito,我喜欢阅读她微醺时的眼眸！
22:53:44.652 [mojito-boss-thread-1] INFO cn.lxchinesszz.mojito.server.netty.NettyServer - Mojito启动成功,端口号:6666
22:53:44.653 [mojito-boss-thread-1] INFO io.netty.handler.logging.LoggingHandler - [id: 0x7fc4d842, L:/0:0:0:0:0:0:0:0:6666] ACTIVE

 
  
Fluent API 风格是自然联系的,仿佛就跟菜单一样,根本不需要去记API。一起都是那么的自然。
 
  
五、总结
 
  
本篇文章爆肝了11天, 因为只有晚上下班,回来才有时间来思考总结。所以进度有点慢。
 
  
文章前部分介绍 Netty API,后半部分介绍基于 Netty 来设计我们的通信层。最终通过
 Fluent API 的风格,将复杂的代码,通过简单的API给暴露了出来。
 
  
但是做到这一步只能说是完成了需求,后面我们还要做压测和调优。
 
  
     
   
  1. 是否可以使用多线程?
    2.  
   
  2. 耗时对象是否可以进行池化?
    3.  
   
  3. 序列化为什么还没有支持 Protostuff?
    4.  
   
  4. 各种异常场景是否都捕捉到了,给出清晰的提示?
    5.  
   
  5. 能否提供更多的扩展功能?
    6.  
  
 
  
mojito-net 只能做RPC吗? 难道不能做一个简单的 web容器? 难道不能实现一个mq 吗?
 
  
 那么你准备好跟我一起Coding了吗?，如果喜欢麻烦点个关注。
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(手写RPC框架系列,java,网络,开发语言)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 2023-04-17|篮球女孩
                        长一木

                        
    1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络
                        落叶无声9
区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
                        
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
    
                    
    • 
                    
  • 2019-08-08
                        65454

                        
    东莞家庭聚会出行旅游去哪里玩住？想起来有很久没有和家里人聚会啦，这次组织家人来到威廉古堡别墅轰趴，一大家子27个人，在别墅订了一天办，玩的非常的开心，小孩子玩游戏机，也很放心不会丢，我们就在唱歌、打麻将、打桌球一系列的活动，还准备小次等小孩生日在别墅举办，还可以给孩子做一个生日的策划
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • MYSQL面试系列-04
                        king01299
面试mysql面试
                        
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
    
                    
    • 
                    
  • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    
                    
    • 
                    
  • 自我意识
                        徐立华

                        
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
                        GPJnCrbBdl
python开发语言
                        
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    
                    
    • 
                    
  • Faiss：高效相似性搜索与聚类的利器
                        网络·魚
大数据faiss
                        
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
    
                    
    • 
                    
  • 《在战“疫”中成长致敬生活》观后感
                        梅子刘的刀

                        
    （作者：周晨）今天上午，我看了“我是接班人”网络大课堂《在战役中成长致敬生活》。有很多人拿出自己攒下的钱，默默地捐给了武汉，有几千块钱的、有几万块钱的，也有十几万块钱的。连小朋友也把自己的压岁钱捐给了武汉。有名环卫工人把自己五年的积蓄全部捐给了武汉。有名外卖小哥为医护人员买鞋子送吃的。还有已经治愈出院的新型肺炎病人捐了400毫升的血浆。还有位叫大树的叔叔，虽然他没有钱，但是他地里有蔬菜，捐了几大卡
    
                    
    • 
                    
  • 果然只有离职的时候，才有人敢说真话！
                        return2ok

                        
    今天公司出了神贴。今天中午吃饭，同事问我看了论坛上的神贴了吗？什么帖子？我问。同事显得很惊讶，你居然没看，现在那个帖子可能会成为年度最佳帖子。这么厉害？我等不及了，饭没吃完就快速的奔向办公室，打开公司论坛，我要一睹这个帖子的神奇。写这帖子的童鞋胆儿真肥。这哪里是一个帖子，这是很多个帖子，组成了一个系列。某人从公司文化、管理、人事、项目管理等多个方面分析了公司的概况，并抨击了公司的各种弊端，并提出了
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 中原焦点团队网络初中级30期阴丽丽坚持分享第三百八十八次2022.10.18分享 约练次数（74） 咨询师（6） 来访者（53） 观察者（15）
                        阴丽丽

                        
    今天是忙碌的一天，一早起来，总想着找点把事情弄完，可总也弄不完。就这样弄着吧！孩子的事，自己的事都在那里搁置着，不想做，有点欧！今天总体还不错，只是在下午起床时走神了俩小时，也算是给自己的放松吧！今日难得1.儿子乖巧、听话，努力配合，一天下来也是忙忙碌碌，这真的很难得！2.儿子今天录的视频被班主任认可，这真的很难得3.我今天早上做核酸时，自己把教案整了一下，这真的很难得
    
                    
    • 
                    
  • 网络编程基础
                        记得开心一点啊
网络
                        
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                                
  • Js函数返回值
                                    _wy_
jsreturn
                                    
    一、返回控制与函数结果，语法为：return 表达式;作用: 结束函数执行，返回调用函数，而且把表达式的值作为函数的结果 二、返回控制语法为：return;作用: 结束函数执行，返回调用函数，而且把undefined作为函数的结果 在大多数情况下,为事件处理函数返回false,可以防止默认的事件行为.例如,默认情况下点击一个<a>元素,页面会跳转到该元素href属性
    
                                
    • 
                                
  • MySQL 的 char 与 varchar
                                    bylijinnan
mysql
                                    
     
今天发现，create table 时，MySQL 4.1有时会把 char 自动转换成 varchar 
 
测试举例： 
 

CREATE TABLE `varcharLessThan4` (
  `lastName` varchar(3)
) ;

mysql> desc varcharLessThan4;
+----------+---------+------+-
    
                                
    • 
                                
  • Quartz——TriggerListener和JobListener
                                    eksliang
TriggerListenerJobListenerquartz
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2208624 一.概述 
listener是一个监听器对象，用于监听scheduler中发生的事件，然后执行相应的操作；你可能已经猜到了，TriggerListeners接受与trigger相关的事件，JobListeners接受与jobs相关的事件。 
  二.JobListener监听器 
 j
    
                                
    • 
                                
  • oracle层次查询
                                    18289753290
oracle；层次查询；树查询
                                    
    .oracle层次查询(connect  by) 
oracle的emp表中包含了一列mgr指出谁是雇员的经理，由于经理也是雇员，所以经理的信息也存储在emp表中。这样emp表就是一个自引用表，表中的mgr列是一个自引用列，它指向emp表中的empno列，mgr表示一个员工的管理者， 
select   empno,mgr,ename,sal  from e
    
                                
    • 
                                
  • 通过反射把map中的属性赋值到实体类bean对象中
                                    酷的飞上天空
javaee泛型类型转换
                                    
    使用过struts2后感觉最方便的就是这个框架能自动把表单的参数赋值到action里面的对象中 
但现在主要使用Spring框架的MVC，虽然也有@ModelAttribute可以使用但是明显感觉不方便。 
好吧，那就自己再造一个轮子吧。 
原理都知道，就是利用反射进行字段的赋值，下面贴代码 
主要类如下： 
  
import java.lang.reflect.Field;
imp
    
                                
    • 
                                
  • SAP HANA数据存储：传统硬盘的瓶颈问题
                                    蓝儿唯美
HANA
                                    
    SAPHANA平台有各种各样的应用场景，这也意味着客户的实施方法有许多种选择，关键是如何挑选最适合他们需求的实施方案。 
在 《Implementing SAP HANA》这本书中，介绍了SAP平台在现实场景中的运作原理，并给出了实施建议和成功案例供参考。本系列文章节选自《Implementing SAP HANA》，介绍了行存储和列存储的各自特点，以及SAP HANA的数据存储方式如何提升空间压
    
                                
    • 
                                
  • Java Socket 多线程实现文件传输
                                    随便小屋
javasocket
                                    
            高级操作系统作业，让用Socket实现文件传输，有些代码也是在网上找的，写的不好，如果大家能用就用上。 
客户端类： 
  
package edu.logic.client;

import java.io.BufferedInputStream;
import java.io.Buffered
    
                                
    • 
                                
  • java初学者路径
                                    aijuans
java
                                    
    学习Java有没有什么捷径?要想学好Java，首先要知道Java的大致分类。自从Sun推出Java以来，就力图使之无所不包，所以Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE,这也就是Sun ONE(Open Net Environment)体系。J2SE就是Java2的标准版，主要用于桌面应用软件的编程；J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；J2EE
    
                                
    • 
                                
  • APP推广
                                    aoyouzi
APP推广
                                    
    一，免费篇 
1，APP推荐类网站自主推荐 
最美应用、酷安网、DEMO8、木蚂蚁发现频道等,如果产品独特新颖，还能获取最美应用的评测推荐。PS：推荐简单。只要产品有趣好玩，用户会自主分享传播。例如足迹APP在最美应用推荐一次，几天用户暴增将服务器击垮。 
2，各大应用商店首发合作 
老实盯着排期，多给应用市场官方负责人献殷勤。 
3，论坛贴吧推广 
百度知道，百度贴吧，猫扑论坛，天涯社区，豆瓣（
    
                                
    • 
                                
  • JSP转发与重定向
                                    百合不是茶
jspservletJava Webjsp转发
                                    
      
在servlet和jsp中我们经常需要请求,这时就需要用到转发和重定向; 
  
转发包括;forward和include   
  
例子;forwrad转发;  将请求装法给reg.html页面 
  
关键代码; 
   
   req.getRequestDispatcher("reg.html
    
                                
    • 
                                
  • web.xml之jsp-config
                                    bijian1013
javaweb.xmlservletjsp-config
                                    
    1.作用：主要用于设定JSP页面的相关配置。 
2.常见定义： 
<jsp-config>
 <taglib>
  <taglib-uri>URI(定义TLD文件的URI,JSP页面的tablib命令可以经由此URI获取到TLD文件)</tablib-uri>
  <taglib-location>
   TLD文件所在的位置

    
                                
    • 
                                
  • JSF2.2 ViewScoped Using CDI
                                    sunjing
CDIJSF 2.2ViewScoped
                                    
    JSF 2.0 introduced annotation @ViewScoped; A bean annotated with this scope maintained its state as long as the user stays on the same view(reloads or navigation - no intervening views). One problem w
    
                                
    • 
                                
  • 【分布式数据一致性二】Zookeeper数据读写一致性
                                    bit1129
zookeeper
                                    
    很多文档说Zookeeper是强一致性保证，事实不然。关于一致性模型请参考http://bit1129.iteye.com/blog/2155336 
  
  Zookeeper的数据同步协议 
Zookeeper采用称为Quorum Based Protocol的数据同步协议。假如Zookeeper集群有N台Zookeeper服务器(N通常取奇数，3台能够满足数据可靠性同时
    
                                
    • 
                                
  • Java开发笔记
                                    白糖_
java开发
                                    
    1、Map<key,value>的remove方法只能识别相同类型的key值 
  
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1,"a");
map.put(2,"b");
map.put(3,"c"
    
                                
    • 
                                
  • 图片黑色阴影
                                    bozch
图片
                                    
     .event{ padding:0;    width:460px;    min-width: 460px;    border:0px solid #e4e4e4;    height: 350px;    min-heig
    
                                
    • 
                                
  • 编程之美-饮料供货-动态规划
                                    bylijinnan
动态规划
                                    
    

import java.util.Arrays;
import java.util.Random;

public class BeverageSupply {

	/**
	 * 编程之美 饮料供货
	 * 设Opt（V’，i）表示从i到n-1种饮料中，总容量为V’的方案中，满意度之和的最大值。
	 * 那么递归式就应该是：Opt（V’，i）=max{ k * Hi+Op
    
                                
    • 
                                
  • ajax大参数（大数据）提交性能分析
                                    chenbowen00
WebAjax框架浏览器prototype
                                    
    近期在项目中发现如下一个问题 
项目中有个提交现场事件的功能，该功能主要是在web客户端保存现场数据（主要有截屏，终端日志等信息）然后提交到服务器上方便我们分析定位问题。客户在使用该功能的过程中反应点击提交后反应很慢，大概要等10到20秒的时间浏览器才能操作，期间页面不响应事件。 
根据客户描述分析了下的代码流程，很简单，主要通过OCX控件截屏，在将前端的日志等文件使用OCX控件打包，在将之转换为
    
                                
    • 
                                
  • [宇宙与天文]在太空采矿,在太空建造
                                    comsci

                                    
         我们在太空进行工业活动...但是不太可能把太空工业产品又运回到地面上进行加工,而一般是在哪里开采,就在哪里加工,太空的微重力环境,可能会使我们的工业产品的制造尺度非常巨大.... 
 
     地球上制造的最大工业机器是超级油轮和航空母舰,再大些就会遇到困难了,但是在空间船坞中,制造的最大工业机器,可能就没
    
                                
    • 
                                
  • ORACLE中CONSTRAINT的四对属性
                                    daizj
oracleCONSTRAINT
                                    
    ORACLE中CONSTRAINT的四对属性 
summary:在data migrate时,某些表的约束总是困扰着我们,让我们的migratet举步维艰,如何利用约束本身的属性来处理这些问题呢?本文详细介绍了约束的四对属性: Deferrable/not deferrable, Deferred/immediate, enalbe/disable, validate/novalidate,以及如
    
                                
    • 
                                
  • Gradle入门教程
                                    dengkane
gradle
                                    
    一、寻找gradle的历程 
一开始的时候，我们只有一个工程，所有要用到的jar包都放到工程目录下面，时间长了，工程越来越大，使用到的jar包也越来越多，难以理解jar之间的依赖关系。再后来我们把旧的工程拆分到不同的工程里，靠ide来管理工程之间的依赖关系，各工程下的jar包依赖是杂乱的。一段时间后，我们发现用ide来管理项程很不方便，比如不方便脱离ide自动构建，于是我们写自己的ant脚本。再后
    
                                
    • 
                                
  • C语言简单循环示例
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int i;
	int count = 0;
	int sum = 0;
	float avg;
	
	for (i=1; i<=100; i++)
	{
		if (i%2==0) 
		{
			count++;
			sum += i;
		}
	}

	avg
    
                                
    • 
                                
  • presentModalViewController 的动画效果
                                    dcj3sjt126com
controller
                                    
    系统自带(四种效果)： 
presentModalViewController模态的动画效果设置：        
[cpp]  
view plain 
copy       
 
 UIViewController *detailViewController = [[UIViewController al
    
                                
    • 
                                
  • java 二分查找
                                    shuizhaosi888
二分查找java二分查找
                                    
    需求：在排好顺序的一串数字中，找到数字T 
  
一般解法：从左到右扫描数据，其运行花费线性时间O(N)。然而这个算法并没有用到该表已经排序的事实。 
	/**
	 * 
	 * @param array
	 *            顺序数组
	 * @param t
	 *            要查找对象
	 * @return
	 */
	public stati
    
                                
    • 
                                
  • Spring Security（07）——缓存UserDetails
                                    234390216
ehcache缓存Spring Security
                                    
     
       Spring Security提供了一个实现了可以缓存UserDetails的UserDetailsService实现类，CachingUserDetailsService。该类的构造接收一个用于真正加载UserDetails的UserDetailsService实现类。当需要加载UserDetails时，其首先会从缓存中获取，如果缓存中没
    
                                
    • 
                                
  • Dozer 深层次复制
                                    jayluns
VOmavenpo
                                    
    最近在做项目上遇到了一些小问题，因为架构在做设计的时候web前段展示用到了vo层，而在后台进行与数据库层操作的时候用到的是Po层。这样在业务层返回vo到控制层，每一次都需要从po-->转化到vo层，用到BeanUtils.copyProperties(source, target)只能复制简单的属性，因为实体类都配置了hibernate那些关联关系，所以它满足不了现在的需求，但后发现还有个很
    
                                
    • 
                                
  • CSS规范整理（摘自懒人图库）
                                    a409435341
htmlUIcss浏览器
                                    
       刚没事闲着在网上瞎逛，找了一篇CSS规范整理，粗略看了一下后还蛮有一定的道理，并自问是否有这样的规范，这也是初入前端开发的人一个很好的规范吧。 
 
 
一、文件规范 
 
1、文件均归档至约定的目录中。 
 
具体要求通过豆瓣的CSS规范进行讲解： 
 
所有的CSS分为两大类：通用类和业务类。通用的CSS文件，放在如下目录中： 
 
基本样式库 /css/core 

    
                                
    • 
                                
  • C++动态链接库创建与使用
                                    你不认识的休道人
C++dll
                                    
    一、创建动态链接库 
1.新建工程test中选择”MFC [dll]”dll类型选择第二项"Regular DLL With MFC shared linked"，完成 
2.在test.h中添加 
extern “C” 返回类型 _declspec(dllexport)函数名(参数列表); 
3.在test.cpp中最后写 
 
extern “C” 返回类型 _decls
    
                                
    • 
                                
  • Android代码混淆之ProGuard
                                    rensanning
ProGuard
                                    
    Android应用的Java代码，通过反编译apk文件（dex2jar、apktool）很容易得到源代码，所以在release版本的apk中一定要混淆一下一些关键的Java源码。 
 
ProGuard是一个开源的Java代码混淆器（obfuscation）。ADT r8开始它被默认集成到了Android SDK中。 
 
官网： 
http://proguard.sourceforge.net/
    
                                
    • 
                                
  • 程序员在编程中遇到的奇葩弱智问题
                                    tomcat_oracle
jquery编程ide
                                    
    　　现在收集一下： 
   
  
  
　　排名不分先后，按照发言顺序来的。 
  
1、Jquery插件一个通用函数一直报错，尤其是很明显是存在的函数，很有可能就是你没有引入jquery。。。或者版本不对 
2、调试半天没变化：不在同一个文件中调试。这个很可怕，我们很多时候会备份好几个项目，改完发现改错了。有个群友说的好：   在汤匙
    
                                
    • 
                                
  • 解决maven-dependency-plugin (goals "copy-dependencies","unpack") is not supported
                                    xp9802
dependency
                                    
    解决办法：在plugins之前添加如下pluginManagement，二者前后顺序如下： 
     
[html]  
view plain 
copy       
 
 <build>   
         <pluginManagement
    
                                
    •