Sentinel之集群限流源码分析（二）

集群限流源码分析（二）

接下来分析sentinel-cluster-server-default模块中server包下的内容。

1、源码目录结构

源码结构

2、源码分析

分析内容

2.1 编解码codec

2.1.1 ServerEntityCodecProvider

编解码提供工具类，用于获取RequestEntityDecoder与ResponseEntityWriter；
源码如下：

public final class ServerEntityCodecProvider {
    private static RequestEntityDecoder requestEntityDecoder = null;
    private static ResponseEntityWriter responseEntityWriter = null;

    static {
        resolveInstance();
    }

    private static void resolveInstance() {
        ResponseEntityWriter writer = SpiLoader.loadFirstInstance(ResponseEntityWriter.class);
        if (writer == null) {
            RecordLog.warn("[ServerEntityCodecProvider] No existing response entity writer, resolve failed");
        } else {
            responseEntityWriter = writer;
            RecordLog.info(
                "[ServerEntityCodecProvider] Response entity writer resolved: " + responseEntityWriter.getClass()
                    .getCanonicalName());
        }
        RequestEntityDecoder decoder = SpiLoader.loadFirstInstance(RequestEntityDecoder.class);
        if (decoder == null) {
            RecordLog.warn("[ServerEntityCodecProvider] No existing request entity decoder, resolve failed");
        } else {
            requestEntityDecoder = decoder;
            RecordLog.info(
                "[ServerEntityCodecProvider] Request entity decoder resolved: " + requestEntityDecoder.getClass()
                    .getCanonicalName());
        }
    }

    public static RequestEntityDecoder getRequestEntityDecoder() {
        return requestEntityDecoder;
    }

    public static ResponseEntityWriter getResponseEntityWriter() {
        return responseEntityWriter;
    }

}

实例变量

• requestEntityDecoder：客户端请求解码器
• responseEntityWriter：服务端响应编码器

静态方法

• resolveInstance：通过SPI机制获取requestEntityDecoder与responseEntityWriter的实现类；并保存在实例变量中。
• requestEntityDecoder与responseEntityWriter实现类分别是DefaultRequestEntityDecoder、DefaultResponseEntityWriter；实现类的指定配置META-INF.services目录下。

2.1.2 DefaultRequestEntityDecoder

默认的ClusterRequest对象解码器
解码格式如下：

• +--------+---------+---------+
• | xid(4) | type(1) | data... |
• +--------+---------+---------+

源码

@Override
public ClusterRequest decode(ByteBuf source) {

    //1. 判断可读的字节数是否大于5个字节
    if (source.readableBytes() >= 5) {

        //2. 获取xid：4个字节
        int xid = source.readInt();

        //3. 获取type 1个字节；三种类型：PING、FLOW、PARAM_FLOW：下文会讲
        int type = source.readByte();

        //4. 从注册器中获取具体类型的解码器
        EntityDecoder dataDecoder = RequestDataDecodeRegistry.getDecoder(type);
        if (dataDecoder == null) {
            RecordLog.warn("Unknown type of request data decoder: {0}", type);
            return null;
        }
        Object data;

        //5. 再次确认下可读取的字节数
        if (source.readableBytes() == 0) {
            data = null;
        } else {

            // 6. 读取数据
            data = dataDecoder.decode(source);
        }
        return new ClusterRequest<>(xid, type, data);
    }
    return null;
}

2.1.3 DefaultResponseEntityWriter

默认的ClusterResponse响应编码器
源码

@Override
public void writeTo(ClusterResponse response, ByteBuf out) {

    //1. 获取响应类型及具体的响应数据编码器
    int type = response.getType();
    EntityWriter responseDataWriter = ResponseDataWriterRegistrygetWriter(type);
    if (responseDataWriter == null) {
        writeHead(response.setStatus(ClusterConstants.RESPONSE_STATUS_BAD), out);
        RecordLog.warn("[NettyResponseEncoder] Cannot find matching writer for type <{0>", response.getType());
        return;
    }

    // 2. 写入头部数据
    writeHead(response, out);

    // 3. 写入数据包
    responseDataWriter.writeTo(response.getData(), out);
}
private void writeHead(Response response, ByteBuf out) {
    out.writeInt(response.getId());
    out.writeByte(response.getType());

    //状态，如错误状态会写入
    out.writeByte(response.getStatus());
}

2.1.3 registry

• RequestDataDecodeRegistry：RequestData解码注册器
• ResponseDataWriterRegistry：ResponseData编码注册器
  源码

public final class RequestDataDecodeRegistry {

    //保存EntityDecoder的Map，key是类型type
    private static final Map> DECODER_MAP = new HashMap<>();

    public static boolean addDecoder(int type, EntityDecoder decoder) {
        if (DECODER_MAP.containsKey(type)) {
            return false;
        }
        DECODER_MAP.put(type, decoder);
        return true;
    }

    public static EntityDecoder getDecoder(int type) {
        return (EntityDecoder)DECODER_MAP.get(type);
    }

    public static boolean removeDecoder(int type) {
        return DECODER_MAP.remove(type) != null;
    }
}
public final class ResponseDataWriterRegistry {

    //保存EntityWriter的Map，key是类型type
    private static final Map> WRITER_MAP = new HashMap<>();

    public static  boolean addWriter(int type, EntityWriter writer) {
        if (WRITER_MAP.containsKey(type)) {
            return false;
        }
        WRITER_MAP.put(type, (EntityWriter)writer);
        return true;
    }

    public static EntityWriter getWriter(int type) {
        return WRITER_MAP.get(type);
    }

    public static boolean remove(int type) {
        return WRITER_MAP.remove(type) != null;
    }
}

源码很简单，可以理解就是一个工具类；那么Map的中编码、解码器数据在哪个地方设置的呢；在后面的init包中源码会分析。

2.1.4 netty

这个包下其实就是handler类了，会放在ChannelPipeline中；在NettyTransportServer启动类中可以看到。
源码分析

public class NettyRequestDecoder extends ByteToMessageDecoder {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List