NIO非阻塞式网络编程

Java 1.4 开始提供了新的非阻塞 API，用意是替代 Java IO 和 Java Networking 相关的 API。
NIO 中有三个核心组件Buffer 缓冲区，Channel 通道，Selector 选择器

1. Buffer

缓冲区本质上是一个可以写入数据的内存块，也可以再次读取。此内存块包含在Buffer对象中，该对象提供了一组方法，可以轻松地使用内存块（数组操作的封装）。

Buffer 有三个重要的属性

capacity 容量
作为一个内存块，buffer 具有一个固定的大小，成为“容量”。
position 位置
写入模式时代表写数据的位置，读取模式时代表读数据的位置。
limit 限制
写入模式，限制等同于 buffer 的容量。读取模式，限制等同于写入的数据量。

以下是 Buffer 操作的例子

public class BufferDemo {
    public static void main(String[] args) {
        // 构建一个 byte 字节缓冲区，容量是4
        ByteBuffer buffer = ByteBuffer.allocate(4);
        // 默认是写入模式，查看三个重要的属性
        System.out.println(String.format("初始化，容量：%s，位置：%s，限制：%s", buffer.capacity(), buffer.position(), buffer.limit()));
        // 写入3字节数据
        buffer.put((byte)1);
        buffer.put((byte)2);
        buffer.put((byte)3);
        // 再次查看三个属性
        System.out.println(String.format("写入3字节后，容量：%s，位置：%s，限制：%s", buffer.capacity(), buffer.position(), buffer.limit()));
        // 开始读取数据（不转入读取模式也是可以读取的，但是 position 记录的位置会不对）
        System.out.println("开始读取");
        buffer.flip();
        byte a = buffer.get();
        System.out.println(a);
        byte b = buffer.get();
        System.out.println(b);
        System.out.println(String.format("读取两字节后，容量：%s，位置：%s，限制：%s", buffer.capacity(), buffer.position(), buffer.limit()));
        // 下面将 buffer 填满
        // 若是在读取模式下写入，只能覆盖一条数据
        // clear() 方法清除整个缓冲区，compact() 方法仅清除已阅读的数据。转为写入模式
        buffer.compact();
        buffer.put((byte)3);
        buffer.put((byte)4);
        buffer.put((byte)5);
        System.out.println(String.format("最后的状态，容量：%s，位置：%s，限制：%s", buffer.capacity(), buffer.position(), buffer.limit()));
    }
}

打印结果为

初始化，容量：4，位置：0，限制：4
写入3字节后，容量：4，位置：3，限制：4
开始读取
1
2
读取两字节后，容量：4，位置：2，限制：3
最后的状态，容量：4，位置：4，限制：4

ByteBuffer 内存类型

ByteBuffer 提供了直接内存（direct堆外）和非直接内存（heap堆）两种实现。
堆外内存直接向操作系统申请内存，获取方式：ByteBuffer directByteBuffer = ByteBuffer.allocateDirect(4);

堆外内存的好处：

进行网络 IO 或文件 IO 时比堆内内存少一次拷贝。socket/file -> 系统内存 -> jvm内存堆
GC 会移动对象内存，在写 file 或 socket 的过程中，也许 JVM 让操作系统读取数据往 file huo socket 中写的时候，GC 触发了，然后 GC 把数据移到别的地方去了，这样操作系统就读不到，所以JVM 的实现，会先把数据复制到堆外，在进行写入。
在 GC 范围之外，可以降低 GC 压力。DirectByteBuffer 中有一个 Cleaner 对象（PhantomReference），Cleaner 被 GC 前会执行 clean 方法，触发 DirectByteBuffer 中定义的 Deallocator。

建议

性能确实客观的时候才去使用；分配给大型、长寿命；（网络传输、大文件读写）。
通过虚拟机参数 MaxDirectMemorySize 限制大小，防止耗尽整个机器的内存。

2. Channel

Buffer 不仅仅是提供了一些接口，其主要是给 Channel 用的。
BIO 中需要用到 net 和 io 包

net + io

而 NIO 的话只需要用到 nio 包

nio

Channel 的 API 涵盖了 TCP/UDP 网络和文件 IO。有 FileChannel，DatagramChannel, SocketChannel,ServerSocketChannel。

下面是 SocketChannel 和 ServerSocketChannel 的例子

服务端

public class NIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞式
        serverSocketChannel.socket().bind(new InetSocketAddress(8080)); // 绑定端口
        System.out.println("启动成功");
        while (true) {
            SocketChannel socketChannel = serverSocketChannel.accept(); // 获取 tcp 连接通道
            if (socketChannel != null) {
                System.out.println("收到新的连接: " + socketChannel.getRemoteAddress());
                socketChannel.configureBlocking(false); // 默认是阻塞的，要设置成非阻塞
                try {
                    ByteBuffer requestByteBuffer = ByteBuffer.allocate(1024);
                    // 长连接情况下，需要手动判断数据有没有读取结束（这里做一个简单的判断，超过 0 就认为请求结束了）
                    while (socketChannel.isOpen() && socketChannel.read(requestByteBuffer) != -1) { // 读到 -1 表示连接已经断开
                        if (requestByteBuffer.position() > 0) {
                            break;
                        }
                    }
                    if (requestByteBuffer.position() == 0) continue; // 如果没有数据 则不继续处理
                    requestByteBuffer.flip();
                    byte[] content = new byte[requestByteBuffer.limit()];
                    requestByteBuffer.get(content);
                    System.out.println(new String(content));
                    System.out.println("收到数据，来自：" + socketChannel.getRemoteAddress());
                    // 响应结果 200
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Length: 11\r\n\r\n" +
                            "Hello World";
                    ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
                    while (responseBuffer.hasRemaining()) {
                        socketChannel.write(responseBuffer);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端

public class NIOClient {
    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
        while (!socketChannel.finishConnect()) {
            // 没连上就一直等待
            Thread.yield();
        }
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入");
        // 发送内容
        String msg = scanner.nextLine();
        ByteBuffer byteBuffer = ByteBuffer.wrap(msg.getBytes());
        while (byteBuffer.hasRemaining()) {
            socketChannel.write(byteBuffer);
        }
        // 读取响应
        System.out.println("收到服务端响应");
        ByteBuffer responseBuffer = ByteBuffer.allocate(1024);

        while (socketChannel.isOpen() && socketChannel.read(responseBuffer) != -1) {
            if (responseBuffer.position() > 0) break;
        }
        responseBuffer.flip();
        byte[] content = new byte[responseBuffer.limit()];
        responseBuffer.get(content);
        System.out.println(new String(content));
        scanner.close();
        socketChannel.close();
    }
}

先启动服务端，然后启动两个客户端，服务端打印如下

启动成功
收到新的连接: /127.0.0.1:1481
123
收到数据，来自：/127.0.0.1:1481
收到新的连接: /127.0.0.1:1487
123
收到数据，来自：/127.0.0.1:1487

因为使用了判断socketChannel.isOpen() && socketChannel.read(requestByteBuffer) != -1当一个客户端断开连接时才会继续，所以要对客户端进行修改，使其能同时连接多个客户端。

下面使用一个列表保存已经连接的 channel，当没有新的连接时去处理这些 channel 的数据

public class NIOServer2 {

    private static ArrayList<SocketChannel> channels = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞式
        serverSocketChannel.socket().bind(new InetSocketAddress(8080)); // 绑定端口
        System.out.println("启动成功");
        while (true) {
            SocketChannel socketChannel = serverSocketChannel.accept(); // 获取 tcp 连接通道
            if (socketChannel != null) {
                System.out.println("收到新的连接: " + socketChannel.getRemoteAddress());
                socketChannel.configureBlocking(false); // 默认是阻塞的，要设置成非阻塞
                channels.add(socketChannel);
            } else if (socketChannel == null) {
                // 没有新连接的情况下，就去处理现有连接数据，处理完就删掉
                Iterator<SocketChannel> iterator = channels.iterator();
                while (iterator.hasNext()) {
                    SocketChannel theSocketChnnel = iterator.next();
                    try {
                        ByteBuffer requestByteBuffer = ByteBuffer.allocate(1024);
                        if (theSocketChnnel.read(requestByteBuffer) == 0) {
                            // 等于 0 就代表这个通道没有数据要处理，就等会再处理
                            continue;
                        }
                        // 长连接情况下，需要手动判断数据有没有读取结束（这里做一个简单的判断，超过 0 就认为请求结束了）
                        while (theSocketChnnel.isOpen() && theSocketChnnel.read(requestByteBuffer) != -1) { // 读到 -1 表示连接已经断开
                            if (requestByteBuffer.position() > 0) {
                                break;
                            }
                        }
                        if (requestByteBuffer.position() == 0) continue; // 如果没有数据 则不继续处理
                        requestByteBuffer.flip();
                        byte[] content = new byte[requestByteBuffer.limit()];
                        requestByteBuffer.get(content);
                        System.out.println(new String(content));
                        System.out.println("收到数据，来自：" + theSocketChnnel.getRemoteAddress());
                        // 响应结果 200
                        String response = "HTTP/1.1 200 OK\r\n" +
                                "Content-Length: 11\r\n\r\n" +
                                "Hello World";
                        ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
                        while (responseBuffer.hasRemaining()) {
                            theSocketChnnel.write(responseBuffer);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    iterator.remove();
                }
            }
        }
    }
}

3. Selector

使用循环检查的效率非常低，NIO 中提供了 Selector 组件，可以检查一个或多个 NIO 通道，并确定哪些通道已经准备好进行读取或写入。实现了单个线程可以管理多个通道，从而管理多个网络连接。

Selector 可以监听 Channel 四个事件，分别对应 SelectionKey 四个常量

Connect 连接（SelectionKey.OP_CONNECT）
Accept 准备就绪（SelectionKey.OP_ACCEPT）
Read 读取（SelectionKey.OP_READ）
Write 写入（SelectionKey.OP_WRITE）

实现一个线程处理多个通道的核心概念是事件驱动机制
非阻塞的网络通道下，开发者对 Selector 注册感兴趣的事件类型，线程通过监听事件来触发相应的代码执行。
（更底层是操作系统的多路复用机制）

下面是使用 Selector 的一个例子

public class NIOServer3 {
    public static void main(String[] args) throws IOException {
        // 1. 创建网络服务端
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞式
        // 2. 构建一个 Selector 选择器，并且把 Channel 注册上去
        Selector selector = Selector.open();
        SelectionKey selectionKey = serverSocketChannel.register(selector, 0, serverSocketChannel);
        selectionKey.interestOps(SelectionKey.OP_ACCEPT); // 对 serverSocketChannel 的 accept 事件感兴趣
        // 3. 绑定端口
        serverSocketChannel.socket().bind(new InetSocketAddress(8080)); // 绑定端口
        System.out.println("启动成功");
        while (true) {
            // 不再轮询通道，改为轮询事件的方式，select 方法有阻塞效果，直到有时间通知才会有返回
            selector.select();
            // 获取事件
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            // 遍历事件
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                // 被封装的查询结果
                SelectionKey key = iterator.next();
                iterator.remove();
                // 对 accept 事件的处理
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.attachment();
                    // 将拿到的客户端连接通道注册到 selector 上面
                    SocketChannel clientSocketChannel = server.accept();
                    clientSocketChannel.configureBlocking(false);
                    clientSocketChannel.register(selector, SelectionKey.OP_READ, clientSocketChannel);
                    System.out.println("收到新的连接：" + clientSocketChannel.getRemoteAddress());
                }
                // 对 read 事件的处理
                if (key.isReadable()){
                    SocketChannel socketChannel = (SocketChannel)key.attachment();
                    try {
                        ByteBuffer requestByteBuffer = ByteBuffer.allocate(1024);
                        while (socketChannel.isOpen() && socketChannel.read(requestByteBuffer) != -1) {
                            if (requestByteBuffer.position() > 0) {
                                break;
                            }
                        }
                        if (requestByteBuffer.position() == 0) continue;
                        requestByteBuffer.flip();
                        byte[] content = new byte[requestByteBuffer.limit()];
                        requestByteBuffer.get(content);
                        System.out.println(new String(content));
                        System.out.println("收到数据，来自：" + socketChannel.getRemoteAddress());
                        // 响应结果 200
                        String response = "HTTP/1.1 200 OK\r\n" +
                                "Content-Length: 11\r\n\r\n" +
                                "Hello World";
                        ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
                        while (responseBuffer.hasRemaining()) {
                            socketChannel.write(responseBuffer);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel(); // 取消事件订阅
                    }
                }
            }
        }
    }
}

服务端输出结果

启动成功
收到新的连接：/127.0.0.1:10380
收到新的连接：/127.0.0.1:10387
123
收到数据，来自：/127.0.0.1:10387
123
收到数据，来自：/127.0.0.1:10380

4. BIO 与 NIO 的区别

Tomcat 8 中已经完全去除 BIO 相关的网络处理代码，默认采用 NIO 进行网络处理。

5. NIO 与多线程结合的改进方案

一个 Selector 监听所有事件，一个线程处理所有时间显然是不合理的，性能会成为瓶颈。

Doug Lea 有一篇著名的文章《Scalable IO in Java》，使用基于 Reactor 的线程模型。

单 Reactor 模式，Reactor 线程接受请求 - > 分发给线程池处理请求
多 Reactor 模式，mainReactor 接收 -> 分发给 subReactor 读写 -> 具体业务逻辑分发给单独的线程池处理

以下是多 Reactor 模式的例子

public class NIOServerV3 {
    // 处理业务操作的线程
    private static ExecutorService workPool = Executors.newCachedThreadPool();

    /**
     * 封装了 selector.select() 等事件轮询代码
     */
    abstract class ReactorThread extends Thread {
        Selector selector;
        LinkedBlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();

        /**
         * 监听到有事件后，调用这个方法
         */
        public abstract void handler(SelectableChannel channel) throws Exception;

        private ReactorThread() throws IOException {
            selector = Selector.open();
        }

        volatile boolean running = false;

        @Override
        public void run() {
            // 轮询 Selector 事件
            while (running) {
                try {
                    Runnable task;
                    while ((task = taskQueue.poll()) != null) {
                        task.run();
                    }
                    selector.select(1000);
                    // 获取查询结果
                    Set<SelectionKey> selected = selector.selectedKeys();
                    Iterator<SelectionKey> iter = selected.iterator();
                    while (iter.hasNext()) {
                        SelectionKey key = (SelectionKey) iter.next();
                        iter.remove();
                        int readOps = key.readyOps();
                        // 关注 Read 和 Accept 两个事件
                        if ((readOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readOps == 0) {
                            try {
                                SelectableChannel channel = (SelectableChannel) key.attachment();
                                channel.configureBlocking(false);
                                handler(channel);
                                if (!channel.isOpen()) {
                                    key.cancel(); // 如果关闭了 则取消这个 key 的订阅
                                }
                            } catch (Exception e) {
                                key.cancel();
                            }
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        private SelectionKey register(SelectableChannel channel) throws Exception {
            // 为什么register要以任务提交的形式，让reactor线程去处理？
            // 因为线程在执行channel注册到selector的过程中，会和调用selector.select()方法的线程争用同一把锁
            // 而select()方法是在eventLoop中通过while循环调用的，争抢的可能性很高，为了让register能更快的执行，就放到同一个线程来处理
            FutureTask<SelectionKey> futureTask = new FutureTask<>(() -> channel.register(selector, 0, channel));
            taskQueue.add(futureTask);
            return futureTask.get();
        }

        private void doStart() {
            if (!running) {
                running = true;
                start();
            }
        }
    }

    private ServerSocketChannel serverSocketChannel;
    // accept 线程
    private ReactorThread[] mainReactorThread = new ReactorThread[1];
    // I/O 线程
    private ReactorThread[] subReactorThreads = new ReactorThread[8];

    /**
     * 初始化线程组
     *
     * @throws Exception
     */
    private void newGroup() throws Exception {
        // 创建 IO 线程，负责处理客户端连接以后的 socketChannel 连接的读写
        for (int i = 0; i < subReactorThreads.length; i++) {
            subReactorThreads[i] = new ReactorThread() {
                @Override
                public void handler(SelectableChannel channel) throws Exception {
                    SocketChannel ch = (SocketChannel) channel;
                    ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
                    // 长连接情况下，需要手动判断数据有没有读取结束（这里做一个简单的判断，超过 0 就认为请求结束了）
                    while (ch.isOpen() && ch.read(requestBuffer) != -1) {
                        if (requestBuffer.position() > 0) {
                            break;
                        }
                    }
                    if (requestBuffer.position() == 0) return;
                    requestBuffer.flip();
                    byte[] content = new byte[requestBuffer.limit()];
                    requestBuffer.get(content);
                    System.out.println(new String(content));
                    System.out.println("收到数据，来自：" + ch.getRemoteAddress());

                    // TODO 业务操作
                    workPool.submit(() -> {
                    });

                    // 响应结果 200
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Length: 11\r\n\r\n" +
                            "Hello World";
                    ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
                    while (responseBuffer.hasRemaining()) {
                        ch.write(responseBuffer);
                    }
                }
            };
        }

        // 创建 mainReactor 线程，只负责处理 serverSockerChannel
        for (int i = 0; i < mainReactorThread.length; i++) {
            mainReactorThread[i] = new ReactorThread() {
                AtomicInteger incr = new AtomicInteger(0);

                @Override
                public void handler(SelectableChannel channel) throws Exception {
                    // 只做请求分发
                    ServerSocketChannel ch = (ServerSocketChannel) channel;
                    SocketChannel socketChannel = ch.accept();
                    socketChannel.configureBlocking(false);
                    // 收到连接建立的通知之后，分发给 I/O 线程去读取
                    int index = incr.getAndIncrement() % subReactorThreads.length;
                    ReactorThread workEventLoop = subReactorThreads[index];
                    workEventLoop.doStart();
                    SelectionKey selectionKey = workEventLoop.register(socketChannel);
                    selectionKey.interestOps(SelectionKey.OP_READ);
                    System.out.println(Thread.currentThread().getName() + "接收到新的连接：" + socketChannel.getRemoteAddress());
                }
            };
        }
    }

    private void initAndRegister() throws Exception {
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        int index = new Random().nextInt(mainReactorThread.length);
        mainReactorThread[index].doStart();
        SelectionKey selectionKey = mainReactorThread[index].register(serverSocketChannel);
        selectionKey.interestOps(SelectionKey.OP_ACCEPT);
    }

    private void bind() throws Exception {
        serverSocketChannel.bind(new InetSocketAddress(8080));
        System.out.println("启动完成");
    }

    public static void main(String[] args) throws Exception {
        NIOServerV3 nioServerV3 = new NIOServerV3();
        nioServerV3.newGroup(); // 1、 创建main和sub两组线程
        nioServerV3.initAndRegister(); // 2、 创建serverSocketChannel，注册到mainReactor线程上的selector上
        nioServerV3.bind(); // 3、 为serverSocketChannel绑定端口
    }
}

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 212,686评论 6赞 492
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,668评论 3赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 158,160评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,736评论 1赞 284
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,847评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,043评论 1赞 291
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,129评论 3赞 410
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,872评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,318评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,645评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,777评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,470评论 4赞 333
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,126评论 3赞 317
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,861评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,095评论 1赞 267
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,589评论 2赞 362
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,687评论 2赞 351