Java IO编程由浅入深 - 5 (项目架构重构)

深碍√TFBOYSˉ_ 2022-11-09 11:21 126阅读 0赞

### 重构之前的bio服务器，提升项目可扩展性 ###

*  目录
 *  github
 *  为什么要重构
 *  新的架构

# 目录 #

1.  [Java IO编程由浅入深 - 1 (bio c/s架构实现)][Java IO_ - 1 _bio c_s]
2.  [Java IO编程由浅入深 - 2(bio 基于字符串的消息编解码器)][Java IO_ - 2_bio]
3.  [Java IO编程由浅入深 - 3 (bio 基于消息长度的解编码器)][Java IO_ - 3 _bio]
4.  [Java IO编程由浅入深 - 4 (bio http协议解编码器，实现http服务器)][Java IO_ - 4 _bio http_http]
5.  [Java IO编程由浅入深 - 5 (项目架构重构)][Java IO_ - 5]
6.  [Java IO编程由浅入深 - 6 (bio实现C/S聊天室 1 )][Java IO_ - 6 _bio_C_S_ 1]
7.  [Java IO编程由浅入深 - 7 (bio实现C/S聊天室 2 )][Java IO_ - 7 _bio_C_S_ 2]
8.  [Java IO编程由浅入深 - 8 (bio实现C/S聊天室 3 )][Java IO_ - 8 _bio_C_S_ 3]
9.  [Java IO编程由浅入深 - 9 (bio实现http升级到websocket )][Java IO_ - 9 _bio_http_websocket]
10. [Java IO编程由浅入深 - 10 (bio 基于websocket的心跳检测实现 )][Java IO_ - 10 _bio _websocket_]

# github #

https://gitee.com/myprofile/learn-io

# 为什么要重构 #

1.  从上次http服务器解析实现之后，我发现之前的架构功能很单一，耦合度很高，不利于后面的迭代与扩展。
2.  如果要是多种协议的解析和处理，之前的架构只能在一个handler里面进行扩展处理，所有的操作都会依赖于一个handler，同时解码编码又是依赖于消息解编码器
3.  socket对象于业务耦合太高，同时消息不能实现多输出形式，一次请求只能响应一次，降低了交互的效率，同时未能完全依赖bytebuf实现数据交互

# 新的架构 #

1.  借鉴netty的pipeline的设计，我实现了channelPipeline，管理链接对应的处理器，每个channelHandlerContext与本身的channelHandler处理器进行一对一的绑定关系，同时又维护着prev channelHandlerContext和next channelHandlerContext，实现类似netty里面的fireChannelRead的功能，类似责任链模式加策略模式，同时对消息进来的处理方式为从左到右的方式，通过使用者手动触发下一个过滤器的回调，当然，默认是自动的，写消息则从右向左，这样就可以在读和写的过程中编写一些特殊的类实现对数据的解码编码以及加密等功能
2.  我开始定义Channel接口，并创建其实现类SocketChannel，实现对socket进行封装，简化api，实现一些常用的功能，并且将底层socket保护起来

package com.lhstack.bio.channel;
    
    import java.io.IOException;
    
    /** * @author lhstack * 通道 */
    public interface Channel { 
    
        /** * 写消息 * @param msg * @return * @throws IOException */
        Channel write(Object msg) throws IOException;
    
        /** * 写消息 * @param msg * @return * @throws IOException */
        Channel writeAndFlush(Object msg) throws IOException;
    
        /** * 不安全的对象 * @param <T> * @return */
        <T> T unsafe();
    
        /** * 获取管道 * @return */
        ChannelPipeline pipeline();
    
        /** * 属性 * @param key * @param val * @param <T> * @return */
        <T> T attr(Object key, Object val);
    }

package com.lhstack.bio.channel;
    
    import io.netty.buffer.ByteBuf;
    
    import java.io.IOException;
    import java.net.Socket;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /** * @author lhstack * @descrption 对socket封装 */
    public class SocketChannel implements Channel{ 
    
        private final Socket socket;
    
        private ChannelPipeline pipeline;
    
        private final Map<Object,Object> attr;
    
        public SocketChannel(Socket socket){ 
            this.socket = socket;
            this.attr = new ConcurrentHashMap<>();
        }
    
        @Override
        public SocketChannel write(Object msg) throws Exception { 
            AbstractChannelHandlerContext abstractChannelHandlerContext = this.pipeline.getLast();
            abstractChannelHandlerContext.write(msg);
            return this;
        }
    
        @Override
        public SocketChannel writeAndFlush(Object msg) throws Exception { 
            AbstractChannelHandlerContext abstractChannelHandlerContext = this.pipeline.getLast();
            abstractChannelHandlerContext.writeAndFlush(msg);
            return this;
        }
    
        @Override
        public <T> T unsafe() { 
            return (T) this.socket;
        }
    
        public void setPipeline(ChannelPipeline pipeline) { 
            this.pipeline = pipeline;
        }
    
        @Override
        public ChannelPipeline pipeline() { 
            return this.pipeline;
        }
    
        @Override
        public <T> T attr(Object key, Object val) { 
            if(!this.attr.containsKey(key)){ 
                this.attr.put(key,val);
            }
            return (T) this.attr.get(key);
        }
    
    
    }

1.  创建ChannelHandler接口，这个handler定义着链接到消息接受发送以及断开的一系列生命周期函数，通过创建Server的构造函数的方式传入，并且为其绑定一个channelHandlerContext，来触发这个hander的各种函数并且实现调用下一个节点的对应函数

package com.lhstack.bio.channel;
    
    /** * @author lhstack * 通道处理器 */
    public interface ChannelHandler { 
    
        /** * 通道激活 * @param ctx * @throws Exception */
        void channelActive(ChannelHandlerContext ctx) throws Exception;
    
        /** * 初始化方法，默认空处理 * @param ch * @throws Exception */
        default void initializer(Channel ch) throws Exception{ 
    
        }
    
        /** * 通道注册成功 * @param ctx * @throws Exception */
        void channelRegister(ChannelHandlerContext ctx) throws Exception;
    
        /** * 通道注销 * @param ctx * @throws Exception */
        void channelRemove(ChannelHandlerContext ctx) throws Exception;
    
        /** * 通道注销 * @param ctx * @throws Exception */
        void exceptionCatch(ChannelHandlerContext ctx,Throwable throwable) throws Exception;
    
        /** * 读取消息 * @param ctx * @param msg * @throws Exception */
        void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception;
    
        /** * 消息写出 * @param ctx * @param msg * @throws Exception */
        void channelWrite(ChannelHandlerContext ctx, Object msg) throws Exception;
    
    
    
    }

5.定义ChannelHandlerContext接口，管理通道上下文，与上面的channelHandler成1对1的关系，这个context维护的本身节点和上一个以及下一个节点，保证消息进栈，通过默认自动的方式对所有handler的对应函数链式方式向下回调，出栈的消息向上回调，关系的绑定由ChannelPipeline来完成

package com.lhstack.bio.channel;
    
    /** * 通道处理器上下文 * * @author lhstack */
    public interface ChannelHandlerContext { 
    
        /** * 通道上下文绑定的通道 * * @return */
        Channel channel();
    
        /** * 通道上下文的名称 * * @return */
        String name();
    
        /** * 管道 * * @return */
        ChannelPipeline pipeline();
    
        /** * 通道上下文绑定的处理器 * * @return */
        ChannelHandler handler();
    
        /** * 执行下一个active方法 * * @return * @throws Exception */
        ChannelHandlerContext fireChannelActive() throws Exception;
    
        /** * 执行下一个register方法 * * @return * @throws Exception */
        ChannelHandlerContext fireChannelRegister() throws Exception;
    
        /** * 执行下一个通道上下文的注销方法 * @return */
        ChannelHandlerContext fireChannelUnregistered() throws Exception;
    
        /** * 执行下一个通道上下文的一次处理方法 * @param cause * @return */
        ChannelHandlerContext fireExceptionCaught(Throwable cause) throws Exception;
    
        /** * 执行下一个通道上下文的读取方法 * @param msg * @return */
        ChannelHandlerContext fireChannelRead(Object msg) throws Exception;
    
        /** * 属性 * @param key * @param val * @param <T> * @return */
        <T> T attr(Object key, Object val);
    
        /** * 执行上一个通道上下文writeAndFlush方法 * @throws Exception * @param msg */
        void writeAndFlush(Object msg) throws Exception;
    
        /** * 执行上一个通道上下文write方法 * @param msg * @throws Exception */
        void write(Object msg) throws Exception;
    }

6.创建ChannelInitializeHandler.java类，帮助使用者可以添加更多的handler，而不需要自己去实现更顶层的类来完成这种功能

package com.lhstack.bio.channel;
    
    /** * @author lhstack * 通道初始化 */
    public abstract class ChannelInitializeHandler implements ChannelHandler { 
    
    
        /** * init * @param ch * @throws Exception */
        @Override
        public abstract void initializer(Channel ch) throws Exception;
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception { 
            ctx.fireChannelActive();
        }
    
        @Override
        public void channelRegister(ChannelHandlerContext ctx) throws Exception { 
            ctx.fireChannelRegister();
        }
    
        @Override
        public void channelRemove(ChannelHandlerContext ctx) throws Exception { 
            ctx.fireChannelUnregistered();
        }
    
        @Override
        public void exceptionCatch(ChannelHandlerContext ctx, Throwable throwable) throws Exception { 
            ctx.fireExceptionCaught(throwable);
        }
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
            ctx.fireChannelRead(msg);
        }
    
        @Override
        public void channelWrite(ChannelHandlerContext ctx, Object msg) throws Exception { 
            ctx.write(msg);
        }
    }

6.创建channelHandlerAdapter，帮助使用者去实现想要实现的函数，而不是每次实现所有的

package com.lhstack.bio.channel;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.util.ReferenceCountUtil;
    
    /** * @author lhstack * 通道处理器适配器 */
    public class ChannelHandlerAdapter implements ChannelHandler{ 
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception { 
            ctx.fireChannelActive();
        }
    
        @Override
        public void channelRegister(ChannelHandlerContext ctx) throws Exception { 
            ctx.fireChannelRegister();
        }
    
        @Override
        public void channelRemove(ChannelHandlerContext ctx) throws Exception { 
            ctx.fireChannelUnregistered();
        }
    
        @Override
        public void exceptionCatch(ChannelHandlerContext ctx, Throwable throwable) throws Exception { 
            ctx.fireExceptionCaught(throwable);
        }
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
            ctx.fireChannelRead(msg);
        }
    
        @Override
        public void channelWrite(ChannelHandlerContext ctx, Object msg) throws Exception { 
            ctx.write(msg instanceof ByteBuf ? ((ByteBuf) msg).copy() : msg);
            ReferenceCountUtil.release(msg);
        }
    }

1.  定义通用的消息解编码器，封装好现成的解码编码抽象类，简化解码编码的过程  
    ByteToMessageCodec

package com.lhstack.bio.codec;
    
    import com.lhstack.bio.channel.ChannelHandlerAdapter;
    import com.lhstack.bio.channel.ChannelHandlerContext;
    import com.lhstack.bio.utils.TypeUtils;
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.util.ReferenceCountUtil;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @author lhstack * 消息编解码器 */
    public abstract class ByteToMessageCodec<T> extends ChannelHandlerAdapter { 
    
    
        /** * 消息编码器 * @param ctx 通道上下文 * @param msg 被编码的消息 * @param buf 编码成功后输出到out * @throws Exception */
        protected abstract void messageEncoder(ChannelHandlerContext ctx, T msg,ByteBuf buf) throws Exception;
    
    
        /** * messageDecoder * 将ByteBuf解码成message 解码器的buf不需要回收，框架会自动回收 * @param buf 接收的数据 * @param ctx 通道上下文处理器 * @param out 解码后输出到out即可 * @return Object */
        protected abstract void messageDecoder(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out);
    
    
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
            if(msg instanceof ByteBuf){ 
                List<Object> list = new ArrayList<>();
                this.messageDecoder(ctx, (ByteBuf) msg,list);
                if(!list.isEmpty()){ 
                    for (Object o : list) { 
                        ctx.fireChannelRead(o);
                        ReferenceCountUtil.safeRelease(o);
                    }
                }
            }else{ 
                ctx.fireChannelRead(msg);
            }
        }
    
        /** * 通道写出消息时，会从低至上的方式 * @param ctx * @param msg * @throws Exception */
        @Override
        public void channelWrite(ChannelHandlerContext ctx, Object msg) throws Exception { 
            if(TypeUtils.mainGenClassSupport(this.getClass(),msg.getClass())){ 
                ByteBuf buf = Unpooled.buffer(128);
                this.messageEncoder(ctx, (T) msg,buf);
                if(buf.isReadable()){ 
                    ctx.write(buf);
                }
            }
        }
    }

9.ByteToMessageDecoder.java

package com.lhstack.bio.codec;
    
    import com.lhstack.bio.channel.ChannelHandlerAdapter;
    import com.lhstack.bio.channel.ChannelHandlerContext;
    import io.netty.buffer.ByteBuf;
    import io.netty.util.ReferenceCountUtil;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @author lhstack * 消息解码器 */
    public abstract class ByteToMessageDecoder extends ChannelHandlerAdapter { 
    
        /** * messageDecoder * 将ByteBuf解码成message * @param buf 接收的数据 * @param ctx 通道上下文处理器 * @param out 解码后输出到out即可 * @return Object */
        protected abstract void messageDecoder(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out);
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
            if(msg instanceof ByteBuf){ 
                List<Object> list = new ArrayList<>();
                this.messageDecoder(ctx, (ByteBuf) msg,list);
                if(!list.isEmpty()){ 
                    for (Object o : list) { 
                        ctx.fireChannelRead(o);
                        ReferenceCountUtil.safeRelease(o);
                    }
                }
            }else{ 
                ctx.fireChannelRead(msg);
            }
        }
    }

10.MessageToByteEncoder.java

11.将之前的StringMessageCodec以及LengthMessageCodec等编码器迁移到新的实现方式，  
StringMessageCodec.java

package com.lhstack.bio.codec.string;
    
    import com.lhstack.bio.channel.ChannelHandlerContext;
    import com.lhstack.bio.codec.ByteToMessageCodec;
    import io.netty.buffer.ByteBuf;
    
    import java.nio.charset.StandardCharsets;
    import java.util.List;
    
    /** * @author lhstack * 字符串消息编解码器 */
    public class StringMessageCodec extends ByteToMessageCodec<String> { 
        @Override
        protected void messageEncoder(ChannelHandlerContext ctx, String msg, ByteBuf buf) throws Exception { 
            buf.writeBytes(msg.getBytes(StandardCharsets.UTF_8));
        }
    
        @Override
        protected void messageDecoder(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out) { 
            if(buf.isReadable()){ 
                byte[] bytes = new byte[buf.readableBytes()];
                buf.readBytes(bytes);
                out.add(new String(bytes,StandardCharsets.UTF_8));
            }
        }
    }

LengthMessageCodec.java

package com.lhstack.bio.codec.length;
    
    import com.lhstack.bio.channel.ChannelHandlerContext;
    import com.lhstack.bio.codec.ByteToMessageCodec;
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    
    import java.util.List;
    
    /** * @author lhstack * 基于消息长度的编解码器 */
    public class LengthMessageCodec extends ByteToMessageCodec<ByteBuf> { 
    
        private final LengthConstant constant;
    
        public LengthMessageCodec(LengthConstant constant){ 
            this.constant = constant;
        }
    
        public LengthMessageCodec(){ 
            this.constant = LengthConstant.INT;
        }
    
        @Override
        protected void messageEncoder(ChannelHandlerContext ctx, ByteBuf msg, ByteBuf buf) throws Exception { 
            if(msg.isReadable()){ 
                switch (constant){ 
                    case BYTE:{ 
                        buf.writeByte(msg.readableBytes())
                                .writeBytes(msg);
                    }break;
                    case SHORT:{ 
                        buf.writeShort(msg.readableBytes())
                                .writeBytes(msg);
                    }break;
                    case MEDIUM:{ 
                        buf.writeMedium(msg.readableBytes())
                                .writeBytes(msg);
                    }break;
                    case INT:{ 
                        buf.writeInt(msg.readableBytes())
                                .writeBytes(msg);
                    }break;
                    case LONG:{ 
                        buf.writeLong(msg.readableBytes())
                                .writeBytes(msg);
                    }break;
                    default:{ 
    
                    }
                }
            }
        }
    
        @Override
        protected void messageDecoder(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out) { 
            if(buf.isReadable()){ 
                buf.markReaderIndex();
                switch (constant){ 
                    case BYTE:{ 
                        int len = buf.readByte();
                        if(buf.readableBytes() > len){ 
                            ByteBuf buffer = Unpooled.buffer(len);
                            buf.readBytes(buffer);
                            out.add(buffer);
                        }else{ 
                            buf.resetReaderIndex();
                        }
                    }break;
                    case SHORT:{ 
                        int len = buf.readShort();
                        if(buf.readableBytes() > len){ 
                            ByteBuf buffer = Unpooled.buffer(len);
                            buf.readBytes(buffer);
                            out.add(buffer);
                        }else{ 
                            buf.resetReaderIndex();
                        }
                    }break;
                    case MEDIUM:{ 
                        int len = buf.readMedium();
                        if(buf.readableBytes() > len){ 
                            ByteBuf buffer = Unpooled.buffer(len);
                            buf.readBytes(buffer);
                            out.add(buffer);
                        }else{ 
                            buf.resetReaderIndex();
                        }
                    }break;
                    case INT:{ 
                        int len = buf.readInt();
                        if(buf.readableBytes() >= len){ 
                            ByteBuf buffer = Unpooled.buffer(len);
                            buf.readBytes(buffer);
                            out.add(buffer);
                        }else{ 
                            buf.resetReaderIndex();
                        }
                    }break;
                    case LONG:{ 
                        long len = buf.readLong();
                        if(buf.readableBytes() > len){ 
                            ByteBuf buffer = Unpooled.buffer((int) len);
                            buf.readBytes(buffer);
                            out.add(buffer);
                        }else{ 
                            buf.resetReaderIndex();
                        }
                    }break;
                    default:{ 
    
                    }
                }
            }
        }
    }

使用案例，同netty类似的api

package com.lhstack.example;
    
    import com.lhstack.bio.Server;
    import com.lhstack.bio.codec.length.LengthConstant;
    import com.lhstack.bio.codec.length.LengthMessageDecoder;
    import com.lhstack.bio.codec.length.LengthMessageEncoder;
    import com.lhstack.bio.codec.string.StringMessageCodec;
    import com.lhstack.bio.codec.string.StringMessageDecoder;
    import com.lhstack.bio.channel.*;
    import com.lhstack.bio.codec.string.StringMessageEncoder;
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    
    import java.nio.charset.StandardCharsets;
    
    /** * @author lhstack * @description 测试bio server */
    public class ServerTest { 
    
        public static void main(String[] args) throws Exception { 
            Server server = new Server(8080, 200, new ChannelInitializeHandler() { 
    
                @Override
                public void initializer(Channel ch) throws Exception { 
                    ChannelPipeline pipeline = ch.pipeline();
                    pipeline.addLast(new LengthMessageDecoder(LengthConstant.INT))
                    .addLast(new ChannelHandlerAdapter(){ 
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
                            if(msg instanceof ByteBuf){ 
                                System.out.println(((ByteBuf) msg).toString(StandardCharsets.UTF_8));
                            }
                            ctx.writeAndFlush(Unpooled.wrappedBuffer("我是服务端".getBytes(StandardCharsets.UTF_8)));
                        }
                    });
                }
            });
            server.start();
        }
    }

实现我们的客户端

package com.lhstack.example;
    
    import java.io.DataOutputStream;
    import java.io.InputStream;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    import java.net.StandardSocketOptions;
    import java.nio.charset.StandardCharsets;
    
    /** * @author lhstack * @description 测试bio client */
    public class ClientTest { 
    
    
        public static void main(String[] args) throws Exception{ 
            Socket socket = new Socket();
            socket.connect(new InetSocketAddress(8080));
            socket.setOption(StandardSocketOptions.SO_SNDBUF,128);
            byte[] msg = "hello wasdfdfddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddasaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaorld".getBytes(StandardCharsets.UTF_8);
            DataOutputStream dot = new DataOutputStream(socket.getOutputStream());
            dot.writeInt(msg.length);
            dot.write(msg);
            dot.flush();
            InputStream inputStream = socket.getInputStream();
            byte[] bytes = new byte[512];
            int len = 0;
            while((len = inputStream.read(bytes)) > 0){ 
                System.out.println(new String(bytes));
                socket.getOutputStream().write("hello world".getBytes(StandardCharsets.UTF_8));
            }
        }
    }

运行效果如下  
因为使用了netty-buffer中的byteBuf类，所以在初始化的时候，会打印ByteBuf相关的信息  
服务端效果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70]  
客户端效果如下  
![在这里插入图片描述][20210314205459241.png]  
接下来的一段时间，我会继续完善此项目的一些api，同时完成一些案例，比如上次说的多客户端互相通信等等

[Java IO_ - 1 _bio c_s]: https://blog.csdn.net/qq_42413011/article/details/114553235
[Java IO_ - 2_bio]: https://blog.csdn.net/qq_42413011/article/details/114579502
[Java IO_ - 3 _bio]: https://blog.csdn.net/qq_42413011/article/details/114636827
[Java IO_ - 4 _bio http_http]: https://blog.csdn.net/qq_42413011/article/details/114646159
[Java IO_ - 5]: https://blog.csdn.net/qq_42413011/article/details/114802496
[Java IO_ - 6 _bio_C_S_ 1]: https://blog.csdn.net/qq_42413011/article/details/114852932
[Java IO_ - 7 _bio_C_S_ 2]: https://blog.csdn.net/qq_42413011/article/details/114878895
[Java IO_ - 8 _bio_C_S_ 3]: https://blog.csdn.net/qq_42413011/article/details/114896029
[Java IO_ - 9 _bio_http_websocket]: https://blog.csdn.net/qq_42413011/article/details/114925184
[Java IO_ - 10 _bio _websocket_]: https://blog.csdn.net/qq_42413011/article/details/114947311
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70]: /images/20221023/a7d80dc85d9d4ef09b020bf8eb83a1b0.png
[20210314205459241.png]: /images/20221023/6764c9a2b6d54f339308c7a11289fcd9.png