• Netty——NIO（Selector处理read事件 消息边界问题）代码示例

    目录

    一、处理消息边界的方式

    • 第一种思路：固定消息长度，数据包大小一样，服务器按预定长度读取，缺点是浪费带宽。
    • 第二种思路：按分隔符拆分，缺点是效率低。
    • 第二种思路：TLV 格式，即 Type 类型、Length 长度、Value 数据，类型和长度已知的情况下，就可以方便获取消息大小，分配合适的 buffer，缺点是 buffer 需要提前分配，如果内容过大，则影响 server 吞吐量。
      （1）、 Http 1.1 是 TLV 格式
      （2）、Http 2.0 是 LTV 格式

    二、未处理消息边界的代码示例

    2.1、服务端代码示例

    • 服务端代码

      package com.example.nettytest.nio.day3;

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;

import static com.example.nettytest.nio.day1.ByteBufferUtil.debugAll;

/**
 * @description: Selector处理read事件（消息边界问题） 代码示例
 * @author: xz
 * @create: 2022-09-04
 */
@Slf4j
public class Test5Server {
    public static void main(String[] args) {
        nioSelectorReadServer();
    }
    /**
     * 1、消息边界问题
     * */
    private static void nioSelectorReadServer(){
        try {
            // 1. 创建 selector, 管理多个 channel
            Selector selector = Selector.open();
            ServerSocketChannel ssc = ServerSocketChannel.open();
            ssc.configureBlocking(false);
            // 2. 建立 selector 和 channel 的联系（注册）
            // SelectionKey 就是将来事件发生后，通过它可以知道事件和哪个channel的事件
            SelectionKey sscKey = ssc.register(selector, 0, null);
            // key 只关注 accept 事件
            sscKey.interestOps(SelectionKey.OP_ACCEPT);
            log.debug("sscKey:{}", sscKey);
            ssc.bind(new InetSocketAddress(8080));
            while (true) {
                // 3. select 方法, 没有事件发生，线程阻塞，有事件，线程才会恢复运行
                // select 在事件未处理时，它不会阻塞, 事件发生后要么处理，要么取消，不能置之不理
                selector.select();
                // 4. 处理事件, selectedKeys 内部包含了所有发生的事件
                Iterator<SelectionKey> iter = selector.selectedKeys().iterator(); // accept, read
                while (iter.hasNext()) {
                    SelectionKey key = iter.next();
                    // 处理key 时，要从 selectedKeys 集合中删除，否则下次处理就会有问题
                    iter.remove();
                    log.debug("key: {}", key);
                    // 5. 区分事件类型
                    if (key.isAcceptable()) { // 如果是 accept
                        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                        SocketChannel sc = channel.accept();
                        sc.configureBlocking(false);
                        SelectionKey scKey = sc.register(selector, 0, null);
                        scKey.interestOps(SelectionKey.OP_READ);
                        log.debug("{}", sc);
                        log.debug("scKey:{}", scKey);
                    } else if (key.isReadable()) { // 如果是 read
                        try {
                            SocketChannel channel = (SocketChannel) key.channel(); // 拿到触发事件的channel
                            //分配ByteBuffer容量4个字节
                            ByteBuffer buffer = ByteBuffer.allocate(4);
                            int read=channel.read(buffer); // 如果是正常断开，read 的方法的返回值是 -1
                            if(read == -1) {
                                key.cancel();
                            } else {
                                buffer.flip();
                                System.out.println(Charset.defaultCharset().decode(buffer));
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                            // 因为客户端断开了,因此需要将 key 取消（从 selector 的 keys 集合中真正删除 key）
                            key.cancel();
                        }

                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88

    2.2、客户端代码示例

    • 客户端代码示例

      package com.example.nettytest.nio.day3;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

/**
 * @description:
 * @author: xz
 * @create: 2022-09-04
 */
public class Test5Client {
    public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open();
        sc.connect(new InetSocketAddress("localhost", 8080));
        SocketAddress address = sc.getLocalAddress();
        //超过服务端设置的ByteBuffer容量4个字节
        sc.write(Charset.defaultCharset().encode("123456789abcd\n"));
        System.out.println("waiting...");
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23

    2.3、工具类

    • 工具类，打印输入、输出数据使用

      package com.example.nettytest.nio.day1;

import io.netty.util.internal.StringUtil;

import java.nio.ByteBuffer;

import static io.netty.util.internal.MathUtil.isOutOfBounds;
import static io.netty.util.internal.StringUtil.NEWLINE;

public class ByteBufferUtil {
    private static final char[] BYTE2CHAR = new char[256];
    private static final char[] HEXDUMP_TABLE = new char[256 * 4];
    private static final String[] HEXPADDING = new String[16];
    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
    private static final String[] BYTE2HEX = new String[256];
    private static final String[] BYTEPADDING = new String[16];

    static {
        final char[] DIGITS = "0123456789abcdef".toCharArray();
        for (int i = 0; i < 256; i++) {
            HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
            HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
        }

        int i;

        // Generate the lookup table for hex dump paddings
        for (i = 0; i < HEXPADDING.length; i++) {
            int padding = HEXPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding * 3);
            for (int j = 0; j < padding; j++) {
                buf.append("   ");
            }
            HEXPADDING[i] = buf.toString();
        }

        // Generate the lookup table for the start-offset header in each row (up to 64KiB).
        for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
            StringBuilder buf = new StringBuilder(12);
            buf.append(NEWLINE);
            buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
            buf.setCharAt(buf.length() - 9, '|');
            buf.append('|');
            HEXDUMP_ROWPREFIXES[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-hex-dump conversion
        for (i = 0; i < BYTE2HEX.length; i++) {
            BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
        }

        // Generate the lookup table for byte dump paddings
        for (i = 0; i < BYTEPADDING.length; i++) {
            int padding = BYTEPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding);
            for (int j = 0; j < padding; j++) {
                buf.append(' ');
            }
            BYTEPADDING[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-char conversion
        for (i = 0; i < BYTE2CHAR.length; i++) {
            if (i <= 0x1f || i >= 0x7f) {
                BYTE2CHAR[i] = '.';
            } else {
                BYTE2CHAR[i] = (char) i;
            }
        }
    }

    /**
     * 打印所有内容
     * @param buffer
     */
    public static void debugAll(ByteBuffer buffer) {
        int oldlimit = buffer.limit();
        buffer.limit(buffer.capacity());
        StringBuilder origin = new StringBuilder(256);
        appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
        System.out.println("+--------+-------------------- all ------------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
        System.out.println(origin);
        buffer.limit(oldlimit);
    }

    /**
     * 打印可读取内容
     * @param buffer
     */
    public static void debugRead(ByteBuffer buffer) {
        StringBuilder builder = new StringBuilder(256);
        appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
        System.out.println("+--------+-------------------- read -----------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
        System.out.println(builder);
    }

    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{97, 98, 99, 100});
        debugAll(buffer);
    }

    private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
        if (isOutOfBounds(offset, length, buf.capacity())) {
            throw new IndexOutOfBoundsException(
                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
                            + ") <= " + "buf.capacity(" + buf.capacity() + ')');
        }
        if (length == 0) {
            return;
        }
        dump.append(
                "         +-------------------------------------------------+" +
                        NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
                        NEWLINE + "+--------+-------------------------------------------------+----------------+");

        final int startIndex = offset;
        final int fullRows = length >>> 4;
        final int remainder = length & 0xF;

        // Dump the rows which have 16 bytes.
        for (int row = 0; row < fullRows; row++) {
            int rowStartIndex = (row << 4) + startIndex;

            // Per-row prefix.
            appendHexDumpRowPrefix(dump, row, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + 16;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(" |");

            // ASCII dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append('|');
        }

        // Dump the last row which has less than 16 bytes.
        if (remainder != 0) {
            int rowStartIndex = (fullRows << 4) + startIndex;
            appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + remainder;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(HEXPADDING[remainder]);
            dump.append(" |");

            // Ascii dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append(BYTEPADDING[remainder]);
            dump.append('|');
        }

        dump.append(NEWLINE +
                "+--------+-------------------------------------------------+----------------+");
    }

    private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
        if (row < HEXDUMP_ROWPREFIXES.length) {
            dump.append(HEXDUMP_ROWPREFIXES[row]);
        } else {
            dump.append(NEWLINE);
            dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
            dump.setCharAt(dump.length() - 9, '|');
            dump.append('|');
        }
    }

    public static short getUnsignedByte(ByteBuffer buffer, int index) {
        return (short) (buffer.get(index) & 0xFF);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
      • 127
      • 128
      • 129
      • 130
      • 131
      • 132
      • 133
      • 134
      • 135
      • 136
      • 137
      • 138
      • 139
      • 140
      • 141
      • 142
      • 143
      • 144
      • 145
      • 146
      • 147
      • 148
      • 149
      • 150
      • 151
      • 152
      • 153
      • 154
      • 155
      • 156
      • 157
      • 158
      • 159
      • 160
      • 161
      • 162
      • 163
      • 164
      • 165
      • 166
      • 167
      • 168
      • 169
      • 170
      • 171
      • 172
      • 173
      • 174
      • 175
      • 176
      • 177
      • 178
      • 179
      • 180
      • 181
      • 182
      • 183

    2.4、启动服务端和客户端进行测试

    • 启动服务端，控制台输出如下：

      在这里插入图片描述

    • debug模式启动客户端【再System.out.println(“waiting…”)代码位置加断点】
      在这里插入图片描述

    • 然后查服务端看控制台输出如下：
      在这里插入图片描述

    三、处理消息边界（按分隔符拆分的方式）的代码示例

    3.1、修改服务端代码示例

    • 再处理read事件代码中，代码修如下：

      try {
    SocketChannel channel = (SocketChannel) key.channel(); // 拿到触发事件的channel
    // 获取 selectionKey 上关联的附件
    ByteBuffer buffer = (ByteBuffer) key.attachment();
    int read=channel.read(buffer); // 如果是正常断开，read 的方法的返回值是 -1
    if(read == -1) {
        key.cancel();
    } else {
        //按 \n 分隔的数据,处理消息边界
        split(buffer);
        // 需要扩容
        if (buffer.position() == buffer.limit()) {
            ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity() * 2);
            buffer.flip();
            newBuffer.put(buffer); // 0123456789abcdef3333\n
            key.attach(newBuffer);
        }
    }
} catch (IOException e) {
    e.printStackTrace();
    // 因为客户端断开了,因此需要将 key 取消（从 selector 的 keys 集合中真正删除 key）
    key.cancel();
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      /**
 * 将错乱的数据恢复成原始的按 \n 分隔的数据方法
 * */
public static void split(ByteBuffer sourceByteBuffer){
    //flip 切换到读模式
    sourceByteBuffer.flip();
    for(int i = 0; i < sourceByteBuffer.limit(); i++){
        if(sourceByteBuffer.get(i) =='\n'){//找到一条完整消息
            //换行符索引+1-起始位置
            int length =i + 1- sourceByteBuffer.position();
            // 把此条完整消息存入新的 ByteBuffer
            ByteBuffer targetByteBuffer = ByteBuffer.allocate(length);
            for(int j=0;j<length;j++){
                targetByteBuffer.put(sourceByteBuffer.get());
            }
            //打印byteBuffer中所有内容
            debugAll(targetByteBuffer);
        }
    }
    //compact 把未读完的部分向前压缩，然后切换至写模式
    sourceByteBuffer.compact();
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22

    3.2、服务端修改后的完整代码

    • 修改后的完整代码示例

      package com.example.nettytest.nio.day3;

import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import static com.example.nettytest.nio.day1.ByteBufferUtil.debugAll;
/**
 * @description: Selector处理read事件（消息边界问题） 代码示例
 * @author: xz
 * @create: 2022-09-04
 */
@Slf4j
public class Test5Server {
    public static void main(String[] args) {
        nioSelectorReadServer();
    }
    /**
     * 2、处理消息边界
     * */
    private static void nioSelectorReadServer(){
        try {
            // 1. 创建 selector, 管理多个 channel
            Selector selector = Selector.open();
            ServerSocketChannel ssc = ServerSocketChannel.open();
            ssc.configureBlocking(false);
            // 2. 建立 selector 和 channel 的联系（注册）
            // SelectionKey 就是将来事件发生后，通过它可以知道事件和哪个channel的事件
            SelectionKey sscKey = ssc.register(selector, 0, null);
            // key 只关注 accept 事件
            sscKey.interestOps(SelectionKey.OP_ACCEPT);
            log.debug("sscKey:{}", sscKey);
            ssc.bind(new InetSocketAddress(8080));
            while (true) {
                // 3. select 方法, 没有事件发生，线程阻塞，有事件，线程才会恢复运行
                // select 在事件未处理时，它不会阻塞, 事件发生后要么处理，要么取消，不能置之不理
                selector.select();
                // 4. 处理事件, selectedKeys 内部包含了所有发生的事件
                Iterator<SelectionKey> iter = selector.selectedKeys().iterator(); // accept, read
                while (iter.hasNext()) {
                    SelectionKey key = iter.next();
                    // 处理key 时，要从 selectedKeys 集合中删除，否则下次处理就会有问题
                    iter.remove();
                    log.debug("key: {}", key);
                    // 5. 区分事件类型
                    if (key.isAcceptable()) { // 如果是 accept
                        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                        SocketChannel sc = channel.accept();
                        sc.configureBlocking(false);
                        ByteBuffer buffer = ByteBuffer.allocate(4);
                        // 将一个 byteBuffer 作为附件关联到 selectionKey 上
                        SelectionKey scKey = sc.register(selector, 0, buffer);// attachment
                        scKey.interestOps(SelectionKey.OP_READ);
                        log.debug("{}", sc);
                        log.debug("scKey:{}", scKey);
                    } else if (key.isReadable()) { // 如果是 read
                        try {
                            SocketChannel channel = (SocketChannel) key.channel(); // 拿到触发事件的channel
                            // 获取 selectionKey 上关联的附件
                            ByteBuffer buffer = (ByteBuffer) key.attachment();
                            int read=channel.read(buffer); // 如果是正常断开，read 的方法的返回值是 -1
                            if(read == -1) {
                                key.cancel();
                            } else {
                                //按 \n 分隔的数据,处理消息边界
                                split(buffer);
                                // 需要扩容
                                if (buffer.position() == buffer.limit()) {
                                    ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity() * 2);
                                    buffer.flip();
                                    newBuffer.put(buffer); // 0123456789abcdef3333\n
                                    key.attach(newBuffer);
                                }
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                            // 因为客户端断开了,因此需要将 key 取消（从 selector 的 keys 集合中真正删除 key）
                            key.cancel();
                        }

                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 将错乱的数据恢复成原始的按 \n 分隔的数据方法
     * */
    public static void split(ByteBuffer sourceByteBuffer){
        //flip 切换到读模式
        sourceByteBuffer.flip();
        for(int i = 0; i < sourceByteBuffer.limit(); i++){
            if(sourceByteBuffer.get(i) =='\n'){//找到一条完整消息
                //换行符索引+1-起始位置
                int length =i + 1- sourceByteBuffer.position();
                // 把此条完整消息存入新的 ByteBuffer
                ByteBuffer targetByteBuffer = ByteBuffer.allocate(length);
                for(int j=0;j<length;j++){
                    targetByteBuffer.put(sourceByteBuffer.get());
                }
                //打印byteBuffer中所有内容
                debugAll(targetByteBuffer);
            }
        }
        //compact 把未读完的部分向前压缩，然后切换至写模式
        sourceByteBuffer.compact();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117

    3.3、启动服务端和客户端进行测试

    • 启动服务端，控制台输出如下：
      在这里插入图片描述
    • debug模式启动客户端【再System.out.println(“waiting…”)代码位置加断点】
      在这里插入图片描述
    • 然后查服务端看控制台输出如下：
      在这里插入图片描述
  • 相关阅读:
    Java基础之 JDK8 HashMap 源码分析（中间写出与JDK7的区别）
    pip install rosbag最正确方法网上其他都不对
    如何使用 Midjourney换脸，将一个人面部复制并粘贴到任意人身上
    探花交友_第2章_环境搭建（新版）
    B2B营销新策略 | B2B企业如何实现产品导向增长目标（附方案下载）
    Shell脚本：Linux Shell脚本学习指南（第二部分Shell编程）一
    【OneDrive篇】OneDrive禁用个人保管库（网页端）
    Spring之AOP
    产品工作流| B端产品竞品分析
    Prometheus Operator 通过additional 添加target
  • 原文地址：https://blog.csdn.net/li1325169021/article/details/126695691