RPC框架设计-2-NIO编程

最新推荐文章于 2022-11-23 20:17:49 发布
最新推荐文章于 2022-11-23 20:17:49 发布
阅读量406 收藏 1
点赞数
分类专栏： IO模型 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxxiaoyuan/article/details/124583978
版权

文章目录

一、NIO介绍

Java NIO 全称java non-blocking IO ，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为NIO(即 New IO)，是同步非阻塞的

1、NIO有三大核心部分：Channel（通道），Buffer（缓冲区），Selector（选择器）
2、NIO是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络
3、Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不获取，而不是保持线程阻塞，所以直至数据便的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程可以同时去做别的事情。
通俗理解：NIO可以做到用一个线程来处理多个操作。假设有10000个请求过来，根据实际情况，可以分配50或者100个线程来处理。不像BIO必须分配10000个线程

二、NIO和BIO的比较

1、BIO以流的方式处理数据，而NIO以缓冲区的方式处理数据，缓冲区I/O的效率比流I/O高很多
2、BIO是阻塞的，NIO则是非阻塞的
3、BIO基于字节流和字符流进行操作，而NIO基于Channel(通道)和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件（比如：链接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道

三、NIO三大核心原理示意图

下面这张图描述了NIO的Selector、Channel、和Buffer的关系
在这里插入图片描述
1、每一个channel都会对应一个buffer
2、Selector本身是一个线程，它对应多个channel（连接）
3、每个channel都注册到Selector选择器上
4、Selector不断轮询查看Channel上的事件，事件是通道Channel非常重要的概念
5、Selector会根据不同的事件，完成不同的处理操作（交给Server的具体执行线程）
6、Buffer就是一个内存块，底层是一个数组
7、数据的读取写入都是通过Buffer，这个也和BIO不同，BIO中要么是输入流、要么是输出流，不能双向，但是NIO中的Buffer是可以读也可以写，channel（通道）是双向的

四、Buffer（缓冲区）

4.1 Buffer的基本介绍

缓冲区（Buffer）：本质上是一个可以读写数据的内存块，可以理解为是一个数组，该对象提供了一组方法，可以更轻松的使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel提供从网络读取数据的渠道，但是读取或者写入的数据都必须经由Buffer
如下图：
在这里插入图片描述

4.2 Buffer的常用API

1、Buffer类及其子类
在NIO中，Buffer是一个顶级的父类，他是一个抽象类，常用的缓冲区分别对应byte,short,int,long,float,double,char7种子类
在这里插入图片描述
2、缓冲区对象创建

方法名说明
static ByteBuffer allocate(长度)创建byte类型的指定长度的缓冲区
static ByteBuffer wrap(byte[] array)创建一个有内容的byte类型缓冲区

示例代码：

package com.lagou.buffer;

import java.nio.ByteBuffer;

/**
 * Buffer的创建
 */
public class CreateBufferDemo {
    public static void main(String[] args) {
        //1.创建指定长度的缓冲区  ByteBuffer为例
        ByteBuffer allocate = ByteBuffer.allocate(5);
        for (int i = 0; i < 5; i++) {
            System.out.println(allocate.get());//从缓冲区当中拿去数据
        }
        //会报错. 后续讲解
        //System.out.println(allocate.get());//从缓冲区当中拿去数据

        //2.创建一个有内容的缓冲区
        ByteBuffer wrap = ByteBuffer.wrap("lagou".getBytes());
        for (int i = 0; i < 5; i++) {
            System.out.println(wrap.get());
        }
    }
}

3、缓冲区对象添加数据

方法名说明
int position()/position(int newPosition)获得当前要操作的索引/修改当前要操作的索引位置
int limit()/limit(int newLimit)最多能操作到哪个索引/修改最多能操作的索引位置
int capacity()返回缓冲区的总长度
int remaining()还有多少能操作索引个数
boolean hasRemaining()是否还有能操作
put(byte b)/put(byte[] src)添加一个字节/添加字节数组

图解：
在这里插入图片描述
示例代码：

package com.lagou.buffer;

import java.nio.ByteBuffer;

/**
 * 向缓冲区中添加数据
 */
public class PutBufferDemo {
    public static void main(String[] args) {
        //1.创建一个缓冲区
        ByteBuffer allocate = ByteBuffer.allocate(10);
        System.out.println(allocate.position());//0 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//10 还有多少个可以操作的个数

        System.out.println("----------------");
        // 修改当前索引所在位置
        // allocate.position(1);
        // 修改最多能操作到哪个索引的位置
        // allocate.limit(9);
        // System.out.println(allocate.position());//1 获取当前索引所在位置
        // System.out.println(allocate.limit());//9 最多能操作到哪个索引位置
        // System.out.println(allocate.capacity());//10 返回缓冲区总长度
        // System.out.println(allocate.remaining());//8 还有多少个可以操作的个数

        // 添加一个字节
        allocate.put((byte) 97);
        System.out.println(allocate.position());//1 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//9 还有多少个可以操作的个数

        System.out.println("----------------");
        // 添加一个数组
        allocate.put("abc".getBytes());
        System.out.println(allocate.position());//4 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//6 还有多少个可以操作的个数
        System.out.println("----------------");
        // 添加一个数组
        allocate.put("123456".getBytes());
        System.out.println(allocate.position());//10 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//0 还有多少个可以操作的个数
        System.out.println(allocate.hasRemaining());//false 是否还能操作
        System.out.println("----------------");
        //如果缓冲区满了. 可以调整position位置, 就可以重复写. 会覆盖之前存入索引位置的值
        allocate.position(0);
        allocate.put("123456".getBytes());
        System.out.println(allocate.position());//6 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//4 还有多少个可以操作的个数
        System.out.println(allocate.hasRemaining());//true 是否还能操作

    }
}

如果缓冲区满了. 可以调整position位置, 就可以重复写. 会覆盖之前存入索引位置的值

  1. 缓冲区对象读取数据
方法名说明
flip()写切换读模式 limit设置position位置, position设置0
get()读一个字节
get(byte[] dst)读多个字节
get(int index)读指定索引的字节
rewind()将position设置为0，可以重复读
clear()切换写模式 position设置为0 , limit 设置为 capacity
array()将缓冲区转换成字节数组返回

图解：flip()方法：切换读模式
在这里插入图片描述
图解：clear()方法：切换写模式：position设置为0 , limit 设置为 capacity
在这里插入图片描述

代码实现：

package com.lagou.buffer;

import java.nio.ByteBuffer;

/**
 * 从缓冲区中读取数据
 */
public class GetBufferDemo {
    public static void main(String[] args) {
        //1.创建一个指定长度的缓冲区
        ByteBuffer allocate = ByteBuffer.allocate(10);
        allocate.put("0123".getBytes());
        System.out.println("position:" + allocate.position());//4
        System.out.println("limit:" + allocate.limit());//10
        System.out.println("capacity:" + allocate.capacity());//10
        System.out.println("remaining:" + allocate.remaining());//6

        //切换读模式
        System.out.println("读取数据--------------");
        allocate.flip();
        System.out.println("position:" + allocate.position());//4 -> 0
        System.out.println("limit:" + allocate.limit());//10 -> 4
        System.out.println("capacity:" + allocate.capacity());//10
        System.out.println("remaining:" + allocate.remaining());//6 -> 4
        for (int i = 0; i < allocate.limit(); i++) {
            System.out.println(allocate.get());
        }
        //读取完毕后.继续读取会报错,超过limit值
        //System.out.println(allocate.get());
        //读取指定索引字节
        System.out.println("读取指定索引字节--------------");
        System.out.println(allocate.get(1));

        System.out.println("读取多个字节--------------");
        // 重复读取
        allocate.rewind();
        byte[] bytes = new byte[4];
        allocate.get(bytes);
        System.out.println(new String(bytes));

        // 将缓冲区转化字节数组返回
        System.out.println("将缓冲区转化字节数组返回--------------");
        byte[] array = allocate.array();
        System.out.println(new String(array));

        // 切换写模式,覆盖之前索引所在位置的值
        System.out.println("写模式--------------");
        allocate.clear();
        allocate.put("abc".getBytes());
        System.out.println(new String(allocate.array()));

    }
}

array() 方法会将缓冲区转换成字节数据返回，不论是有值的位置还是没值的位置都会返回

注意事项

  1. capacity:容量(长度) limit: 界限(最多能读/写到哪里) posotion:位置(读/写哪个索引)
  2. 获取缓冲区里面数据之前，需要调用flip方法
  3. 再次写数据之前，需要调用clear方法，但是数据还未消失，等再次写入数据，被覆盖了
    才会消失。

五、Channel（通道）

5.1 Channel的基本介绍

通常来说NIO中的所有IO都是从 Channel(通道) 开始的。NIO 的通道类似于流，但有些区别如下:

  1. 通道可以读也可以写，流一般来说是单向的(只能读或者写，所以之前我们用流进行IO操作的时候需要分别创建一个输入流和一个输出流)
  2. 通道可以异步读写
  3. 通道总是基于缓冲区Buffer来读写
    在这里插入图片描述

5.2 Channel的常用类介绍

  1. Channel接口
    常用的Channel实现类有 :FileChannel , DatagramChannel ,ServerSocketChannel和 SocketChannel 。
    FileChannel 用于文件的数据读写
    DatagramChannel 用于 UDP 的数据读 写
    ServerSocketChannel 和SocketChannel 用于 TCP 的数据读写
    【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】
  2. SocketChannel 与ServerSocketChannel
    类似Socke和ServerSocket,可以完成客户端与服务端数据的通信工作

5.3 ServerSocketChannel代码实现(服务端)

实现步骤:

  1. 打开一个服务端通道
  2. 绑定对应的端口号
  3. 通道默认是阻塞的，需要设置为非阻塞
  4. 检查是否有客户端连接 有客户端连接会返回对应的通道
  5. 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
  6. 给客户端回写数据
  7. 释放资源

代码如下：

package com.lagou.channel;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

/**
 * 服务端
 */
public class NIOServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        //1. 打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2. 绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(9999));
        //3. 通道默认是阻塞的，需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        System.out.println("服务端启动成功...");
        while (true) {
            //4. 检查是否有客户端连接 有客户端连接会返回对应的通道
            SocketChannel socketChannel = serverSocketChannel.accept();
            if (socketChannel == null) {
                System.out.println("没有客户端连接...我先去玩");
                Thread.sleep(1000);
                continue;
            }
            //5. 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
            // 创建一个缓冲区
            ByteBuffer allocate = ByteBuffer.allocate(1024);
            // 通道总是基于缓冲区Buffer来读写的
            int read = socketChannel.read(allocate);
            // 返回值read：
            // 正数：表示本次读到的有效字节数
            // 0：表示本地没有读到数据
            // -1：表示读到末尾
            System.out.println("客户端消息：" + new String(allocate.array(), 0, read, StandardCharsets.UTF_8));
            //6. 给客户端回写数据
            socketChannel.write(ByteBuffer.wrap("来啊".getBytes(StandardCharsets.UTF_8)));
            //7. 释放资源
            socketChannel.close();
        }
    }
}

5.4 SocketChannel代码实现(客户端)

实现步骤:

  1. 打开通道
  2. 设置连接IP和端口号
  3. 写出数据
  4. 读取服务器写回的数据
  5. 释放资源

代码如下：

package com.lagou.channel;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

/**
 * 客户端
 */
public class NIOClient {
    public static void main(String[] args) throws IOException {
        //1. 打开通道
        SocketChannel socketChannel = SocketChannel.open();
        //2. 设置连接IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
        //3. 写出数据
        socketChannel.write(ByteBuffer.wrap("信不信我打你".getBytes(StandardCharsets.UTF_8)));
        //4. 读取服务器写回的数据
        ByteBuffer allocate = ByteBuffer.allocate(1024);
        int read = socketChannel.read(allocate);
        System.out.println("服务端消息："+new String(allocate.array(),0,read,StandardCharsets.UTF_8));
        //5. 释放资源
        socketChannel.close();
    }
}

六、Selector (选择器)

6.1 Selector基本介绍

如果想要用一个线程去处理多个的客户端连接，就会使用到NIO的Selector(选择器). Selector 能够检测多个注册的服务端通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的 处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。

没有Selector（选择器）的时候：对应每个连接对应一个处理线程. 但是连接并不能马上就会发送信息,所以还会产生资源浪费
如下图：如果客户端建立好连接后，没有直接发送消息（写数据）的话，服务端会产生等待，造成资源浪费
在这里插入图片描述
只有在通道真正有读写事件发生时，才进行读写，就可以大大地减少系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程, 避免了多线程之间的上下文切换导致的开销

针对这个需求，NIO提供了Selector（选择器）来解决这个问题，如下图：

首先创建一个服务端，一个选择器，然后将服务端通道注册到选择器上，并指定注册监听的事件为(连接事件)
然后当选择器中有了客户端连接事件后再将客户端通道也注册到选择器上，并指定注册监听的事件为（读事件）
接下来就是当选择器中有了读事件以后进行处理
在这里插入图片描述

6.2 Selector常用API

  1. Selector
    Selector是一个抽象类，里面的一些常用方法如下:
    1）Selector.open() : //得到一个选择器对象
    2）selector.select() : //阻塞 监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入 集合内部并返回事件数量
    3）selector.select(1000): //阻塞 1000 毫秒，监控所有注册的通道,当有对应的事件操作时, 会将 SelectionKey放入集合内部并返回
    4）selector.selectedKeys() : // 返回存有SelectionKey的集合

  2. SelectionKey
    常用方法
    1）SelectionKey.isAcceptable(): 是否是连接继续事件 （表示客户端向服务端已经发送了连接）
    2）SelectionKey.isConnectable(): 是否是连接就绪事件 （表示客户端和服务端连接成功了）
    3）SelectionKey.isReadable(): 是否是读就绪事件
    4）SelectionKey.isWritable(): 是否是写就绪事件
    SelectionKey中定义的4种事件:
    SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
    SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户端与服务器的连接已经建立成功
    SelectionKey.OP_READ —— 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了(通道目前有数据，可以进行读操作了)
    SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了(通道目前可以用 于写操作)

  3. 代码实现Selector

实现步骤:

  1. 打开一个服务端通道
  2. 绑定对应的端口号
  3. 通道默认是阻塞的，需要设置为非阻塞
  4. 创建选择器
  5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
  6. 检查选择器是否有事件
  7. 获取事件集合
  8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
  9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
  10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
  11. 得到客户端通道,读取数据到缓冲区
  12. 给客户端回写数据
  13. 从集合中删除对应的事件, 因为防止二次处理.

代码如下：

package com.lagou.selector;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Set;

/**
 * 服务端-选择器
 */
public class NIOSelectorServer {
    public static void main(String[] args) throws IOException {
        // 1. 打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 2. 绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(9999));
        // 3. 通道默认是阻塞的，需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        // 4. 创建选择器
        Selector selector = Selector.open();
        // 5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT(连接事件)
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务端启动并注册成功...");
        while (true) {
            // 6. 检查选择器是否有事件(select方法返回的是选择器中的事件个数，如果不传入等待时间则一直阻塞)
            int select = selector.select(2000);
            if (select == 0) {
                System.out.println("没有事件发生...");
                continue;
            }
            // 7. 获取事件集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                // 8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
                SelectionKey key = iterator.next();
                if (key.isAcceptable()) {
                    // 9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("有客户端连接了...");
                    // 必须将通道设置成非阻塞状态，因为Selector选择器需要轮询监听每个通道的事件，如果有一个通道是非阻塞的话就无法继续轮询了
                    socketChannel.configureBlocking(false);
                    // 指定监听事件为OP_READ
                    socketChannel.register(selector, SelectionKey.OP_READ);
                }
                // 10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
                if (key.isReadable()) {
                    // 11. 得到客户端通道,读取数据到缓冲区
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer allocate = ByteBuffer.allocate(1024);
                    int read = socketChannel.read(allocate);
                    // 如果读到数据
                    if (read > 0) {
                        System.out.println("客户端消息："+new String(allocate.array(),0,read,StandardCharsets.UTF_8));
                        // 12. 给客户端回写数据
                        socketChannel.write(ByteBuffer.wrap("来啊".getBytes(StandardCharsets.UTF_8)));
                        // 关闭通道
                        socketChannel.close();
                    }
                }
                // 13. 从集合中删除对应的事件, 因为防止二次处理.
                iterator.remove();
            }
        }
    }
}

客户端的代码和上面Channel的保持一致即可

贼不走空？
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用NIO来实现RPC
yinbucheng的博客
05-11 2678
数据传输格式：   客户端调用服务端：     接口简单名/方法名(参数类型权限名：参数值, . ...)     比如  SayHello/sayHello(java.lang.String:lalala)      这里 接口名为SayHello    方法为 sayHello 参数类型为String 内容nana 服务端返回给客户端       返回类型：值 服
java 手写rpc框架 rpc-server and rpc-client
10-14
总的来说，Java手写RPC框架涉及了网络编程、序列化、多线程、服务治理等多个领域的知识，是一个很好的学习和实践分布式系统设计的平台。通过这个项目，开发者不仅可以提升技术水平，还能对分布式系统的运行机制有更...
JAVA系列---NIO/RPC
lipviolet的博客
03-01 376
补充：RPC与NIO
王小禾
06-04 265
参考：https://www.cnblogs.com/zjfstudio/p/4090712.html https://weixiaolu.iteye.com/blog/1479656 1. 阻塞I/O通信模型 假如现在你对阻塞I/O已有了一定了解，我们知道阻塞I/O在调用InputStream.read()方法时是阻塞的，它会一直等到数据到来时（或超时）才会返回；同样，在调用ServerSo...
基于NIO的远程RPC调用
菜鸡也有大佬梦
02-19 613
Tomcat 目录结构 bin / ：存放Tomcat的启动、停止等批处理脚本文件 startup.bat ,startup.sh：用于在windows和linux下的启动脚本 shutdown.bat ,shutdown.sh：用于在windows和linux下的停止脚本 conf /： 用于存放Tomcat的相关配置文件 Catalina：用于存储针对每个虚拟机的Context配...
[Java] 浅析rpc的原理及所用到的基本底层技术
最新发布
ToraNe的博客
11-23 1951
通过本文笔者希望我们大家都能理解rpc的本质到底是什么，这样无论是面对阿帕奇的dubbo、谷歌的gRPC亦或是老旧的SOAP，咱们都能快速的理解其到底是在干什么。 商业产品无穷无尽，唯有理解其本质才能以不变应万变。
Java进阶（2）——NIO之网络IO、Netty、RPC
zzhou——blog
02-23 334
文章目录1.网络IO1.1 概述和核心 API1. Selector(选择器)2. SelectionKey3. ServerSocketChannel4. SocketChannel1.2 入门案例1.3 网络聊天案例 1.网络IO 1.1 概述和核心 API 前面在进行文件 IO 时用到的 FileChannel 并不支持非阻塞操作，学习 NIO 主要就是进行网络 IO操作，Java NIO ...
java实现rpc框架
09-04
RPC框架允许程序通过网络调用远程机器上的方法，就像调用本地方法一样，极大地简化了分布式系统开发。以下将详细讲解在Java中实现RPC框架涉及的核心知识点。 **1. 序列化** 序列化是将对象转换为字节流的过程，以便...
falcon:轻量级RPC框架
05-24
falcon是一个专为简化这一过程而设计的轻量级RPC框架。其核心目标是提供高效、易用且可靠的跨进程通信机制，尤其适用于Java开发环境。 **轻量级特性** falcon作为轻量级框架，意味着它的设计和实现都是为了最小化...
my-rpc-framework
03-20
《my-rpc-framework：构建自己的RPC框架》 在IT行业中，RPC（Remote Procedure ...通过深入研究这个项目，我们可以提升自己的Java编程能力，增强对分布式系统设计的理解，从而在实际工作中更好地应用和优化RPC框架。
最简单的RPC框架源码.zip
11-04
通过对"最简单的RPC框架源码"的分析，我们可以学习到如何设计和实现一个基本的RPC框架，理解其工作流程和核心组件。这将有助于我们更好地理解和使用复杂的RPC框架，如Dubbo、gRPC、Spring Cloud等。
Java实现简单的RPC框架
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
12-12 602
Java实现简单的RPC框架 一、RPC简介 RPC，全称为Remote Procedure Call，即远程过程调用，它是一个计算机通信协议。它允许像调用本地服务一样调用远程服务。它可以有不同的实现方式。如RMI(远程方法调用)、Hessian、Http invoker等。另外，RPC是与语言无关的。 ...
Java-RPC：2)NIO入门初窥
Javis486的专栏
12-01 1116
Java NIO（New IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API Channels and Buffers（通道和缓冲区）：标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中，Channel同时支持读和写。Asynchr
RPC中用到的 *动态代理，反射机制，NIO
silence的博客
09-17 2297
今天在学习RPC协议时，用到了动态代理和反射机制 所以，我们先来看看动态机制：在java的动态代理中，有两个重要的类或接口，一个是InvocationHandler（Interface）,另一个则是Proxy(Class0,这一个类和接口。首先我们来看看java的api对这两个类的描述 ： InvocationHandler: InvocationHandler is the interf
NIO和 RPC框架
weixin_40426261的博客
10-11 114
由于个人原因，后面会补上,欢迎大家关注…
Hadoop RPC Server基于Reactor模式和Java NIO 的架构和原理
小昌昌的博客
08-14 2541
Hadoop RPC Server基于java NIO实现了一个高并发、高稳定性的网络层。本文分析了Hadoop RPC Server在NIO层面的处理逻辑，包括Listener、Reader、Handler、Responder等各个Reactor角色以及请求和响应在它们之间的传递。我们详细分析了一个基于Protobuf RPC的头信息的解析过程，解释了Server端收到请求到将请求交付给业务进行处理的逻辑。
RPC中nio和代理模式的应用
Luck_Ape的博客
11-14 525
RPC NIO和代理模式在rpc中的应用 一、NIO Java NIO（New IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API Channels and Buffers（通道和缓冲区）：标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从
Hadoop RPC实现NIO通信范例
李战磊专栏
11-19 1004
从hadoop的源码中剥离出了ipc，去掉了安全验证等代码，想了解hadoop的rpc的可以看下打印输出，如果想详细了解，做好debug运行试试。 代码见：http://download.csdn.net/detail/lzlchangqi/8182999 下面简单地列出打印日志，后面文章会结合NIO详细介绍有关代码及流程,
网络编程 -- RPC实现原理 -- NIO多线程 -- 迭代版本V1
limeOracle的博客
06-24 92
　　网络编程 -- RPC实现原理 -- 目录 　　啦啦啦 V1——设置标识变量selectionKey.attach(true);只处理一次（会一直循环遍历selectionKeys，占用CPU资源）。 （由于key没有清除，依旧在selectionKeys中存在，遍历时依旧会检测到对应事件，除非socket关闭或调用selectionKey.cancel();清除对应事件） ...
Netty驱动的高性能RPC框架设计与优化实践
"《高性能RPC框架设计与Netty实践》" 在本文中，作者深入探讨了如何利用Netty这一强大的网络编程库来构建一个高效率的分布式服务框架。Netty作为一款成熟的IO框架，专为创建高性能网络应用而设计，它简化了底层Java...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值