Dubbo分析之Serialize层

精尽 Dubbo 源码分析 —— NIO 服务器(二)之 Transport 层 1.概述 dubbo-remoting-api 模块, transport 包,网络传输层。 涉及的类图如下: 2.AbstractPeer 实现 Endpoint、ChannelHandler 接口,Peer 抽象类。 /** * AbstractPeer * * Peer 抽象类 */ public abstract class AbstractPeer implements End... 阅读详情

Dubbo整体设计

关于Dubbo的整体设计可以查看官方文档,下图可以清晰的表达Dubbo的整体设计:
在这里插入图片描述
1.图例说明

图中左边淡蓝背景的为服务消费方使用的接口,右边淡绿色背景的为服务提供方使用的接口,位于中轴线上的为双方都用到的接口;
图中从下至上分为十层,各层均为单向依赖,右边的黑色箭头代表层之间的依赖关系;
图中绿色小块的为扩展接口,蓝色小块为实现类,图中只显示用于关联各层的实现类;
图中蓝色虚线为初始化过程,即启动时组装链,红色实线为方法调用过程,即运行时调时链,紫色三角箭头为继承,可以把子类看作父类的同一个节点,线上的文字为调用的方法;

2.各层说明

config 配置层:对外配置接口,以 ServiceConfig, ReferenceConfig 为中心,可以直接初始化配置类,也可以通过 spring 解析配置生成配置类;
proxy 服务代理层:服务接口透明代理,生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中心,扩展接口为 ProxyFactory;
registry 注册中心层:封装服务地址的注册与发现,以服务 URL 为中心,扩展接口为 RegistryFactory, Registry, RegistryService;
cluster 路由层:封装多个提供者的路由及负载均衡,并桥接注册中心,以 Invoker 为中心,扩展接口为 Cluster, Directory, Router, LoadBalance;
monitor 监控层:RPC 调用次数和调用时间监控,以 Statistics 为中心,扩展接口为 MonitorFactory, Monitor, MonitorService;
protocol 远程调用层:封装 RPC 调用,以 Invocation, Result 为中心,扩展接口为 Protocol, Invoker, Exporter;
exchange 信息交换层:封装请求响应模式,同步转异步,以 Request, Response 为中心,扩展接口为 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer;
transport 网络传输层:抽象 mina 和 netty 为统一接口,以 Message 为中心,扩展接口为 Channel, Transporter, Client, Server, Codec;
serialize 数据序列化层:可复用的一些工具,扩展接口为 Serialization, ObjectInput, ObjectOutput, ThreadPool;

本文将从最底层的serialize层开始来对dubbo进行源码分析;

通讯框架

dubbo的底层通讯使用的是第三方框架,包括:netty,netty4,mina和grizzly;默认使用的是netty,分别提供了server端(服务提供方)和client端(服务消费方);下面已使用的netty为例来看那一下NettyServer的部分代码:

protected void doOpen() throws Throwable {
        NettyHelper.setNettyLoggerFactory();
        ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
        ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
        ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
        bootstrap = new ServerBootstrap(channelFactory);
 
        final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
        channels = nettyHandler.getChannels();
        // https://issues.jboss.org/browse/NETTY-365
        // https://issues.jboss.org/browse/NETTY-379
        // final Timer timer = new HashedWheelTimer(new NamedThreadFactory("NettyIdleTimer", true));
        bootstrap.setOption("child.tcpNoDelay", true);
        bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            @Override
            public ChannelPipeline getPipeline() {
                NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyServer.this);
                ChannelPipeline pipeline = Channels.pipeline();
                /*int idleTimeout = getIdleTimeout();
                if (idleTimeout > 10000) {
                    pipeline.addLast("timer", new IdleStateHandler(timer, idleTimeout / 1000, 0, 0));
                }*/
                pipeline.addLast("decoder", adapter.getDecoder());
                pipeline.addLast("encoder", adapter.getEncoder());
                pipeline.addLast("handler", nettyHandler);
                return pipeline;
            }
        });
        // bind
        channel = bootstrap.bind(getBindAddress());
    }

在启动服务提供方时就会调用此doOpen方法,用来启动服务端口,供消费方连接;以上代码就是常规的启动nettyServer端代码,因为本文重点介绍dubbo的序列化,所以这里主要看decoder和encoder,这两个类分别定义在NettyCodecAdapter中:

private final ChannelHandler encoder = new InternalEncoder();
private final ChannelHandler decoder = new InternalDecoder();

1.编码器

在NettyCodecAdapter定义了内部类InternalEncoder:

private class InternalEncoder extends OneToOneEncoder {
 
        @Override
        protected Object encode(ChannelHandlerContext ctx, Channel ch, Object msg) throws Exception {
            com.alibaba.dubbo.remoting.buffer.ChannelBuffer buffer =
                    com.alibaba.dubbo.remoting.buffer.ChannelBuffers.dynamicBuffer(1024);
            NettyChannel channel = NettyChannel.getOrAddChannel(ch, url, handler);
            try {
                codec.encode(channel, buffer, msg);
            } finally {
                NettyChannel.removeChannelIfDisconnected(ch);
            }
            return ChannelBuffers.wrappedBuffer(buffer.toByteBuffer());
        }
    }

此类其实是对codec的包装,本身并没有做编码处理,下面重点看一下codec类,此类是一个接口类,有多种实现类,Codec2源码如下:

@SPI
public interface Codec2 {

  @Adaptive({Constants.CODEC_KEY})
  void encode(Channel channel, ChannelBuffer buffer, Object message) throws IOException;

  @Adaptive({Constants.CODEC_KEY})
  Object decode(Channel channel, ChannelBuffer buffer) throws IOException;


  enum DecodeResult {
      NEED_MORE_INPUT, SKIP_SOME_INPUT
  }

}

实现包括:TransportCodec,TelnetCodec,ExchangeCodec,DubboCountCodec以及ThriftCodec,当然也可以自行扩展;不可能启动时把每种类型都加载,dubbo是通过在配置文件中配置好所有的类型,然后在运行中需要什么类加载什么类,
配置文件的具体路径:META-INF/dubbo/internal/com.alibaba.dubbo.remoting.Codec2,内容如下:

transport=com.alibaba.dubbo.remoting.transport.codec.TransportCodec
telnet=com.alibaba.dubbo.remoting.telnet.codec.TelnetCodec
exchange=com.alibaba.dubbo.remoting.exchange.codec.ExchangeCodec
dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboCountCodec
thrift=com.alibaba.dubbo.rpc.protocol.thrift.ThriftCodec

获取具体Codec2的代码如下:

protected static Codec2 getChannelCodec(URL url) {
    String codecName = url.getParameter(Constants.CODEC_KEY, "telnet");
    if (ExtensionLoader.getExtensionLoader(Codec2.class).hasExtension(codecName)) {
        return ExtensionLoader.getExtensionLoader(Codec2.class).getExtension(codecName);
    } else {
        return new CodecAdapter(ExtensionLoader.getExtensionLoader(Codec.class)
                .getExtension(codecName));
    }
}

通过在url中获取是否有关键字codec,如果有的话就获取当前的值,dubbo默认的codec为dubbo;如果没有值默认为telnet;这里有默认值为dubbo,所以实现类DubboCountCodec会被ExtensionLoader进行加载并进行缓存,下面具体看一下DubboCountCodec的编解码;

private DubboCodec codec = new DubboCodec();
 
@Override
public void encode(Channel channel, ChannelBuffer buffer, Object msg) throws IOException {
    codec.encode(channel, buffer, msg);
}

DubboCountCodec内部调用的是DubboCodec的encode方法,看一下如何对Request对象进行编码的,具体代码块如下:

protected void encodeRequest(Channel channel, ChannelBuffer buffer, Request req) throws IOException {
       Serialization serialization = getSerialization(channel);
       // header.
       byte[] header = new byte[HEADER_LENGTH];
       // set magic number.
       Bytes.short2bytes(MAGIC, header);
 
       // set request and serialization flag.
       header[2] = (byte) (FLAG_REQUEST | serialization.getContentTypeId());
 
       if (req.isTwoWay()) header[2] |= FLAG_TWOWAY;
       if (req.isEvent()) header[2] |= FLAG_EVENT;
 
       // set request id.
       Bytes.long2bytes(req.getId(), header, 4);
 
       // encode request data.
       int savedWriteIndex = buffer.writerIndex();
       buffer.writerIndex(savedWriteIndex + HEADER_LENGTH);
       ChannelBufferOutputStream bos = new ChannelBufferOutputStream(buffer);
       ObjectOutput out = serialization.serialize(channel.getUrl(), bos);
       if (req.isEvent()) {
           encodeEventData(channel, out, req.getData());
       } else {
           encodeRequestData(channel, out, req.getData(), req.getVersion());
       }
       out.flushBuffer();
       if (out instanceof Cleanable) {
           ((Cleanable) out).cleanup();
       }
       bos.flush();
       bos.close();
       int len = bos.writtenBytes();
       checkPayload(channel, len);
       Bytes.int2bytes(len, header, 12);
 
       // write
       buffer.writerIndex(savedWriteIndex);
       buffer.writeBytes(header); // write header.
       buffer.writerIndex(savedWriteIndex + HEADER_LENGTH + len);
   }

前两个字节存放了魔数:0xdabb;第三个字节包含了四个信息分别是:是否是请求消息(还是响应消息),序列化类型,是否双向通信,是否是心跳消息;
在请求消息中直接跳过了第四个字节,直接在5-12位置存放了requestId,是一个long类型,第四个字节在如果是编码响应消息中会存放响应的状态;
代码往下看,buffer跳过了HEADER_LENGTH长度的字节,这里表示的是header部分的长度为16个字节,然后通过指定的序列化方式把data对象序列化到buffer中,序列化之后可以获取到data对象总共的字节数,用一个int类型来保存字节数,此int类型存放在header的最后四个字节中;
最后把buffer的writerIndex设置到写完header和data的地方,防止数据被覆盖;

2.解码器

在NettyCodecAdapter定义了内部类InternalEncoder,同样是调用DubboCodec的decode方法,部分代码如下:

public Object decode(Channel channel, ChannelBuffer buffer) throws IOException {
        int readable = buffer.readableBytes();
        byte[] header = new byte[Math.min(readable, HEADER_LENGTH)];
        buffer.readBytes(header);
        return decode(channel, buffer, readable, header);
    }
 
    @Override
    protected Object decode(Channel channel, ChannelBuffer buffer, int readable, byte[] header) throws IOException {
        // check magic number.
        if (readable > 0 && header[0] != MAGIC_HIGH
                || readable > 1 && header[1] != MAGIC_LOW) {
            int length = header.length;
            if (header.length < readable) {
                header = Bytes.copyOf(header, readable);
                buffer.readBytes(header, length, readable - length);
            }
            for (int i = 1; i < header.length - 1; i++) {
                if (header[i] == MAGIC_HIGH && header[i + 1] == MAGIC_LOW) {
                    buffer.readerIndex(buffer.readerIndex() - header.length + i);
                    header = Bytes.copyOf(header, i);
                    break;
                }
            }
            return super.decode(channel, buffer, readable, header);
        }
        // check length.
        if (readable < HEADER_LENGTH) {
            return DecodeResult.NEED_MORE_INPUT;
        }
 
        // get data length.
        int len = Bytes.bytes2int(header, 12);
        checkPayload(channel, len);
 
        int tt = len + HEADER_LENGTH;
        if (readable < tt) {
            return DecodeResult.NEED_MORE_INPUT;
        }
 
        // limit input stream.
        ChannelBufferInputStream is = new ChannelBufferInputStream(buffer, len);
 
        try {
            return decodeBody(channel, is, header);
        } finally {
            if (is.available() > 0) {
                try {
                    if (logger.isWarnEnabled()) {
                        logger.warn("Skip input stream " + is.available());
                    }
                    StreamUtils.skipUnusedStream(is);
                } catch (IOException e) {
                    logger.warn(e.getMessage(), e);
                }
            }
        }
    }

首先读取Math.min(readable, HEADER_LENGTH),如果readable小于HEADER_LENGTH,表示接收方连头部的16个字节还没接受完,需要等待接收;正常header接收完之后需要进行检查,主要包括:魔数的检查,header消息长度检查,消息体长度检查(检查消息体是否已经接收完成);检查完之后需要对消息体进行反序列化,具体在decodeBody方法中:

@Override
   protected Object decodeBody(Channel channel, InputStream is, byte[] header) throws IOException {
       byte flag = header[2], proto = (byte) (flag & SERIALIZATION_MASK);
       Serialization s = CodecSupport.getSerialization(channel.getUrl(), proto);
       // get request id.
       long id = Bytes.bytes2long(header, 4);
       if ((flag & FLAG_REQUEST) == 0) {
           // decode response.
           Response res = new Response(id);
           if ((flag & FLAG_EVENT) != 0) {
               res.setEvent(Response.HEARTBEAT_EVENT);
           }
           // get status.
           byte status = header[3];
           res.setStatus(status);
           if (status == Response.OK) {
               try {
                   Object data;
                   if (res.isHeartbeat()) {
                       data = decodeHeartbeatData(channel, deserialize(s, channel.getUrl(), is));
                   } else if (res.isEvent()) {
                       data = decodeEventData(channel, deserialize(s, channel.getUrl(), is));
                   } else {
                       DecodeableRpcResult result;
                       if (channel.getUrl().getParameter(
                               Constants.DECODE_IN_IO_THREAD_KEY,
                               Constants.DEFAULT_DECODE_IN_IO_THREAD)) {
                           result = new DecodeableRpcResult(channel, res, is,
                                   (Invocation) getRequestData(id), proto);
                           result.decode();
                       } else {
                           result = new DecodeableRpcResult(channel, res,
                                   new UnsafeByteArrayInputStream(readMessageData(is)),
                                   (Invocation) getRequestData(id), proto);
                       }
                       data = result;
                   }
                   res.setResult(data);
               } catch (Throwable t) {
                   if (log.isWarnEnabled()) {
                       log.warn("Decode response failed: " + t.getMessage(), t);
                   }
                   res.setStatus(Response.CLIENT_ERROR);
                   res.setErrorMessage(StringUtils.toString(t));
               }
           } else {
               res.setErrorMessage(deserialize(s, channel.getUrl(), is).readUTF());
           }
           return res;
       } else {
           // decode request.
           Request req = new Request(id);
           req.setVersion(Version.getProtocolVersion());
           req.setTwoWay((flag & FLAG_TWOWAY) != 0);
           if ((flag & FLAG_EVENT) != 0) {
               req.setEvent(Request.HEARTBEAT_EVENT);
           }
           try {
               Object data;
               if (req.isHeartbeat()) {
                   data = decodeHeartbeatData(channel, deserialize(s, channel.getUrl(), is));
               } else if (req.isEvent()) {
                   data = decodeEventData(channel, deserialize(s, channel.getUrl(), is));
               } else {
                   DecodeableRpcInvocation inv;
                   if (channel.getUrl().getParameter(
                           Constants.DECODE_IN_IO_THREAD_KEY,
                           Constants.DEFAULT_DECODE_IN_IO_THREAD)) {
                       inv = new DecodeableRpcInvocation(channel, req, is, proto);
                       inv.decode();
                   } else {
                       inv = new DecodeableRpcInvocation(channel, req,
                               new UnsafeByteArrayInputStream(readMessageData(is)), proto);
                   }
                   data = inv;
               }
               req.setData(data);
           } catch (Throwable t) {
               if (log.isWarnEnabled()) {
                   log.warn("Decode request failed: " + t.getMessage(), t);
               }
               // bad request
               req.setBroken(true);
               req.setData(t);
           }
           return req;
       }
   }

首先通过解析header部分的第三个字节,识别出是请求消息还是响应消息,还有使用哪种类型的序列化方式,然后分别进行序列化;

序列化和反序列化

通过以上对编码器解码器的了解,在编码器中需要序列化Request/Response,在解码器中需要序列化Request/Response,下面具体看看序列化和反序列化;

1.序列化

在编码器中需要获取具体的Serialization,具体代码如下:

public static Serialization getSerialization(URL url) {
    return ExtensionLoader.getExtensionLoader(Serialization.class).getExtension(
            url.getParameter(Constants.SERIALIZATION_KEY, Constants.DEFAULT_REMOTING_SERIALIZATION));
}

同获取codec的方式,dubbo也提供了多种序列化方式,同时可以自定义扩展;通过在url中获取serialization关键字,如果获取不到默认为hession2;同样多种序列化类也配置在一个文件中,
路径:META-INF/dubbo/internal/com.alibaba.dubbo.common.serialize.Serialization,具体内容如下:

fastjson=com.alibaba.dubbo.common.serialize.fastjson.FastJsonSerialization
fst=com.alibaba.dubbo.common.serialize.fst.FstSerialization
hessian2=com.alibaba.dubbo.common.serialize.hessian2.Hessian2Serialization
java=com.alibaba.dubbo.common.serialize.java.JavaSerialization
compactedjava=com.alibaba.dubbo.common.serialize.java.CompactedJavaSerialization
nativejava=com.alibaba.dubbo.common.serialize.nativejava.NativeJavaSerialization
kryo=com.alibaba.dubbo.common.serialize.kryo.KryoSerialization

dubbo默认提供了fastjson,fst,hessian2,java,compactedjava,nativejava和kryo多种序列化方式;
每种序列化方式都需要实现如下三个接口类:Serialization,ObjectInput以及ObjectOutput;
Serialization接口类:

public interface Serialization {
 
    byte getContentTypeId();
 
    String getContentType();
 
    @Adaptive
    ObjectOutput serialize(URL url, OutputStream output) throws IOException;
 
    @Adaptive
    ObjectInput deserialize(URL url, InputStream input) throws IOException;
 
}

其中的ContentTypeId就是在header中存放的序列化类型,反序列化的时候需要通过此id获取具体的Serialization,所以此ContentTypeId不能出现重复的,否则会被覆盖;
ObjectInput接口类:

public interface ObjectOutput extends DataOutput {
 
    void writeObject(Object obj) throws IOException;
}

ObjectOutput接口类:

public interface ObjectInput extends DataInput {
 
    Object readObject() throws IOException, ClassNotFoundException;
 
    <T> T readObject(Class<T> cls) throws IOException, ClassNotFoundException;
 
    <T> T readObject(Class<T> cls, Type type) throws IOException, ClassNotFoundException;
}

分别提供了读取对象和写对象的接口方法,DataOutput和DataInput分别提供了对基本数据类型的读和写;序列化只需要调用writeObject方法将Data写入数据流即可;具体可以看一下编码器中调用的encodeRequestData方法:

@Override
protected void encodeRequestData(Channel channel, ObjectOutput out, Object data, String version) throws IOException {
    RpcInvocation inv = (RpcInvocation) data;
 
    out.writeUTF(version);
    out.writeUTF(inv.getAttachment(Constants.PATH_KEY));
    out.writeUTF(inv.getAttachment(Constants.VERSION_KEY));
 
    out.writeUTF(inv.getMethodName());
    out.writeUTF(ReflectUtils.getDesc(inv.getParameterTypes()));
    Object[] args = inv.getArguments();
    if (args != null)
        for (int i = 0; i < args.length; i++) {
            out.writeObject(encodeInvocationArgument(channel, inv, i));
        }
    out.writeObject(inv.getAttachments());
}

默认使用的DubboCountCodec方式并没有直接将data写入流中,而是将RpcInvocation中的数据取出分别写入流;

2.反序列化

反序列化通过读取header中的序列化类型,然后通过如下方法获取具体的Serialization,具体在类CodecSupport中:

public static Serialization getSerialization(URL url, Byte id) throws IOException {
    Serialization serialization = getSerializationById(id);
    String serializationName = url.getParameter(Constants.SERIALIZATION_KEY, Constants.DEFAULT_REMOTING_SERIALIZATION);
    // Check if "serialization id" passed from network matches the id on this side(only take effect for JDK serialization), for security purpose.
    if (serialization == null
            || ((id == 3 || id == 7 || id == 4) && !(serializationName.equals(ID_SERIALIZATIONNAME_MAP.get(id))))) {
        throw new IOException("Unexpected serialization id:" + id + " received from network, please check if the peer send the right id.");
    }
    return serialization;
}
 
private static Map<Byte, Serialization> ID_SERIALIZATION_MAP = new HashMap<Byte, Serialization>();
 
public static Serialization getSerializationById(Byte id) {
    return ID_SERIALIZATION_MAP.get(id);
}

ID_SERIALIZATION_MAP存放着ContentTypeId和具体Serialization的对应关系,然后通过id获取具体的Serialization,然后根据写入的顺序读取数据;

扩展序列化类型

dubbo本身对很多模块提供了很好的扩展功能,包括序列化功能,以下来分析一下如何使用protobuf来实现序列化方式;

1.整体代码结构

首先看一下整体的代码结构,如下图所示:
在这里插入图片描述
分别实现三个接口类:Serialization,ObjectInput以及ObjectOutput;然后在指定目录下提供一个文本文件;

2.引入扩展包

<dependency>
     <groupId>com.dyuproject.protostuff</groupId>
     <artifactId>protostuff-core</artifactId>
     <version>1.1.3</version>
</dependency>
<dependency>
     <groupId>com.dyuproject.protostuff</groupId>
     <artifactId>protostuff-runtime</artifactId>
     <version>1.1.3</version>
</dependency>

3.实现接口ObjectInput和ObjectOutput

public class ProtobufObjectInput implements ObjectInput {
 
    private ObjectInputStream input;
 
    public ProtobufObjectInput(InputStream inputStream) throws IOException {
        this.input = new ObjectInputStream(inputStream);
    }
 
    ....省略基础类型...
     
    @Override
    public Object readObject() throws IOException, ClassNotFoundException {
        return input.readObject();
    }
 
    @Override
    public <T> T readObject(Class<T> clazz) throws IOException {
        try {
            byte[] buffer = (byte[]) input.readObject();
            input.read(buffer);
            return SerializationUtil.deserialize(buffer, clazz);
        } catch (Exception e) {
            throw new IOException(e);
        }
 
    }
 
    @Override
    public <T> T readObject(Class<T> clazz, Type type) throws IOException {
        try {
            byte[] buffer = (byte[]) input.readObject();
            input.read(buffer);
            return SerializationUtil.deserialize(buffer, clazz);
        } catch (Exception e) {
            throw new IOException(e);
        }
    }
}
 
public class ProtobufObjectOutput implements ObjectOutput {
 
    private ObjectOutputStream outputStream;
 
    public ProtobufObjectOutput(OutputStream outputStream) throws IOException {
        this.outputStream = new ObjectOutputStream(outputStream);
    }
 
    ....省略基础类型...
 
    @Override
    public void writeObject(Object v) throws IOException {
        byte[] bytes = SerializationUtil.serialize(v);
        outputStream.writeObject(bytes);
        outputStream.flush();
    }
 
    @Override
    public void flushBuffer() throws IOException {
        outputStream.flush();
    }
}

4.实现Serialization接口

public class ProtobufSerialization implements Serialization {
 
    @Override
    public byte getContentTypeId() {
        return 10;
    }
 
    @Override
    public String getContentType() {
        return "x-application/protobuf";
    }
 
    @Override
    public ObjectOutput serialize(URL url, OutputStream out) throws IOException {
        return new ProtobufObjectOutput(out);
    }
 
    @Override
    public ObjectInput deserialize(URL url, InputStream is) throws IOException {
        return new ProtobufObjectInput(is);
    }
}

这里引入了一个新的ContentTypeId,需要保证和dubbo里面已存在的不要冲突

5.指定目录提供注册

在META-INF/dubbo/internal/目录下提供文件com.alibaba.dubbo.common.serialize.Serialization,内容如下:

protobuf=com.dubboCommon.ProtobufSerialization

6.在提供方配置新的序列化方式

<dubbo:protocol name="dubbo" port="20880" serialization="protobuf"/>

这样就会使用新扩展的protobuf序列化方式来序列化对象;

总结

本文从dubbo整体设计的最底层serialization层来分析和了解dubbo,后面会逐层进行分析,对dubbo有一个更加透彻的了解;

示例代码地址

https://github.com/ksfzhaohui…

https://gitee.com/OutOfMemory/blog

推荐阅读:https://www.roncoo.com/course/list.html?courseName=Dubbo
v

Dubbo源码分析- 总体介绍与模块划分 registry 注册中心层:封装服务地址的注册与发现,以服务 URL 为中心,扩展接口为 RegistryFactory, Registry, RegistryService。 cluster 路由层:封装多个提供者的路由及负载均衡,并桥接注册中心,以 Invoker 为中心,扩展接口为 Cluster, Directory, Router, LoadBalance。相当于将集群封装为单个节点,这样外部就可以像单体调用一样处理,不需要考虑集群的情况(比如多个提供方的情况) monitor 监控.. 阅读详情

相关推荐

比较器和运算放大器-2

今天继续了解输入阻抗问题,观察下图:首先考虑在我们没有接运放时,A点输出电压为6V,当接入如图所示的阻抗时电压还是6V吗?共模电阻和红框内对地电阻并联,阻值变小,相当于5k,通过计算可以求得A点电压变为4V,这样A的值发生了改变,试想一下这样的信号接入到运放的两端是不是相当于比较的两端信号发生了改变,那结果一定会发生偏离。信号源一般内阻是不确定的,一般也不是很小,如果不想改变输入阻抗,那唯一的办法就是改变运放的内阻了,比如内阻改为100K,1M等,越大越好,是不是A点电压就会无限接近6V。

weixin_42855218的博客 1312

dubbo之Serialization

dubbo序列化原理,及序列化工具如何选用介绍

懒猫的脚印 1332

FTP新手必看:vsftpd 530登录错误的8种实战解决方案(附详细配置步骤)

本文针对FTP服务配置中常见的vsftpd 530登录错误,提供了8种实战解决方案。从理解错误本质入手,系统性地排查用户列表策略、PAM认证、系统黑名单、Shell限制、目录权限及DNS解析等问题,并附有详细的配置步骤与命令,帮助新手快速定位并解决登录失败难题。

ik678901的博客 697

Dubbo分层设计之Serialize层

Serialization 被设计成 SPI 接口,所以它可以很轻松的被替换。接下来,我们就基于 Fastjson2 写一个序列化模块,替换掉默认的 hessian2,让你对整个序列化过程理解的更加清楚。首先,我们新建一个模块。因为我们要依赖 Dubbo 提供的接口去实现一套新的序列化组件,所以自然要引入模块。又因为我们是基于 fastjson2 实现的,所以也得引入 fastjson2 的依赖。

程序员小潘 1547

CentOS Stream 9中安装MySQL的详细步骤

本文详细介绍了在CentOS Stream 9系统中如何进行MySQL的在线安装、离线安装以及忘记密码的恢复操作。通过阅读本文,您将能够了解并掌握在CentOS Stream 9上安装MySQL的步骤,以及在遇到忘记密码的情况下的解决方案。

小白典的博客 7258

什么是PON(无源光纤网络)、PON的发展及演进

全球知名媒体Omdia在光纤和铜缆接入设备预测报告中对2022年2月的预测显示,PON设备端口收入预计在2020年至2027年期间以12.3%的年复合增长率增长,到2027年将达到163亿美元,远高于2020年的82亿美元。 此前,Omdia有份报告称,在3月份举行的美国OFC展会中,众多 CSP 正在顺利部署 XGS PON(10G 对称),其他 CSP 专注于基于 GPON 的低速 FTTH 服务。另外关于25G PON 和 50G PON 之间的争论仍在继续,而Omdia 认为 25G PON 和 5

4932

Dubbo序列化与反序列化问题、服务端获取到的请求参数类型转换异常(变成了Map类型的对象)

Dubbo相关问题合集

IccBoY_超越 2158

开源ISP实战(1)——基于Zynq7020的Vivado工程移植与调试

本文详细介绍了将开源ISP项目移植到正点原子Zynq7020开发板的实战过程。重点阐述了在Vivado中进行工程创建、IP核导入、Block Design框架搭建、时钟配置与管脚约束修改等关键步骤,并提供了系统联调与常见问题的排查思路,为FPGA图像处理开发者提供了完整的移植与调试指南。

weixin_29191081的博客 204

9-Dubbo源码分析之:Remoting层:Dubbo Serialize 层:多种序列化算法,总有一款适合你

在本课时,我们首先介绍了 Java 序列化的基础知识,帮助你快速了解序列化和反序列化的基本概念。然后,介绍了常见的序列化算法,例如,Arvo、Fastjson、Fst、Kryo、Hessian、Protobuf 等。最后,深入分析了 dubbo-serialization 模块对各个序列化算法的接入方式,其中重点说明了 Hessian2 序列化方式。

952

072、LLC谐振变换器的谐振电容选型

文章摘要: 本文深入探讨了LLC谐振变换器中谐振电容的选型要点。作者通过实际案例指出,谐振电容的高频特性(如ESR、ESL)会显著影响LLC性能,导致死区振铃或EMI问题。对比薄膜电容(稳定性好但体积大)和MLCC(体积小但存在直流偏置与温漂缺陷),建议100W以上优先选薄膜电容。强调需关注容值精度、耐压、纹波电流及布局对称性,避免寄生参数引发谐振异常。最后提出验证方法(热成像与波形观测)及选型清单,并分享经验:薄膜电容可靠性更优,MLCC需严格测试,布局时应缩短走线以降低环路辐射。

Jack010169的博客 232

基于DPCNN实现电商情感分析任务

下载链接项目中使用的模型是DPCNN,在模型中我们定义了三个组件,分别是embedding层,卷积层和全连接层。Embedding层:将每个词生成对应的嵌入向量,就是利用一个连续型向量来表示每个词卷积层:提取语句中的语义信息Linear层:将结果映射成2大小用于二分类,即正反面的概率。

优快云 精品推荐 1629

1-Dubbo初学-框架

Dubbo 1、dubbo文件核心目录 1.1、dubbo-common ​ Dubbo通用模块,定义了业务无关的工具类例如io处理、日志处理、配置处理、类处理等等操作,以及对于线程池的扩展,二进制编码处理,class编译处理,json数据处理,数据持久化接口处理等等。 1.2、dubbo-rpc-api ​ 分布式服务调用框架RPC的核心基本实现,可以看到其中提供了很多的RPC抽象类、接口和实现类,包括服务发布,服务调用,远程调用,RPC调用网络协议,RPC条用监听和过滤器等功能。提供了默认的基于Dubb

qq_35251212的博客 1697

手把手完整实现STM32+ESP8266+MQTT+ThingsCloud云平台+Android App及iOS App及微信小程序及Web App应用

本教程文章完整记录实现STM32+ESP8266+MQTT+ThingsCloud云平台+Android App及iOS App及微信小程序及Web App应用。

嵌入式阿齐Archie 1万+

Dubbo源码解读与实战-服务通信

在本课时,我们首先介绍了 Java 序列化的基础知识,帮助你快速了解序列化和反序列化的基本概念。然后,介绍了常见的序列化算法,例如,Arvo、Fastjson、Fst、Kryo、Hessian、Protobuf 等。最后,深入分析了 dubbo-serialization 模块对各个序列化算法的接入方式,其中重点说明了 Hessian2 序列化方式。本课时我们首先介绍了 dubbo-remoting 模块在 Dubbo 架构中的位置,以及 dubbo-remoting 模块的结构。

小小博客 642

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

dubbo原理整理(菜鸟笔记)

dubbo的框架 config 配置层:对外配置接口,以 ServiceConfig, ReferenceConfig 为中心,可以直接初始化配置类,也可以通过 spring 解析配置生成配置类 proxy 服务代理层:服务接口透明代理,生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy为中心,扩展接口为 ProxyFactory registry 注册中...

Zohar的博客 262

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Dubbo源码解析-远程调用

1.主要调用流程解析 一个简单的RPC框架调用,涉及代理与网络通信,协议设计等技术的应用,RPC调用需要将调用信息从客户端传递到服务端,其中信息包括了调用接口、调用方法名、方法参数类型和参数值等,在传递方法参数值时需要先序列化对象转化为二进制流并经过网络传输到服务端,在服务端需要按照客户端的序列方法反序列化二进制字节流。Dubbo的一次完整的RPC调用流程如下所示。 客户端每次启动都会从注册中心拉取和订阅对应的服务列表,Cluster会把拉取的服务列表聚合成一个Inv...

Newerwu的专栏 427

Jasna 视频马赛克修复完整指南:模型选型、显存参数与 CLI 实践

Jasna 是一款在 GPU 上运行的视频马赛克修复工具:它找出视频里的马赛克、重新生成,其余画面原样保留,解码、检测、修复、编码整条链路都跑在显卡上。免费的 BasicVSR++ 对大多数人够用,LTX 是付费进阶模型。全文按问题组织:能不能跑、首跑要等多久、选哪个模型、显存紧时降哪个参数、只修一部分怎么做。 ## 30 秒锁定默认方案 | 项目 | 推荐选择 | 代价 | | --- |

gitblog_00537的博客 218

dubbo源码实践-serialize层的例子

本文描述了dubbo serialize层API的简单使用。 原理请自行网上搜索(网上描述的都比较详细了,就不在copy一份了。)。

Alf的专栏 795

Dubbo源码解析-Dubbo架构的实现

前言: 在经过前面的学习之后,我们对Dubbo consumer、provider处理请求的过程有了一个基本了解。 从本文开始,我们就要对Dubbo框架进行拆解,讲解每一个具体的技术点了。这样从使用到每层的技术点分析,可以完整的掌握整个Dubbo框架。 本文就先从框架的整体面貌讲起,逐层来分析,后续针对每一个层次都会有专门的文章来说明。 1.Dubbo架构图 Dubbo的相关架构比较复杂,主要是分层次比较多。每层之间基本都是通过SPI的方式来生成调用的。 通过SPI方式的调用,具有高度的灵活

恐龙弟旺仔的博客 1798

Dubbo Serialize 层的多种序列化算法

在本课时,我们首先介绍了 Java 序列化的基础知识,帮助你快速了解序列化和反序列化的基本概念。然后,介绍了常见的序列化算法,例如,Arvo、Fastjson、Fst、Kryo、Hessian、Protobuf 等。最后,深入分析了 dubbo-serialization 模块对各个序列化算法的接入方式,其中重点说明了 Hessian2 序列化方式。

daobuxinzi的博客 416

Apache Dubbo项目中serialize.allowlist文件被覆盖问题的分析与解决方案

在Apache Dubbo 3.2.5版本中,开发者在使用maven-assembly-plugin打包包含依赖的单一JAR文件时,遇到了一个关于安全序列化白名单文件(security/serialize.allowlist)被意外覆盖的问题。这个问题直接影响了Dubbo框架的安全序列化功能,导致自定义的白名单类无法被正确识别。 ## 问题现象 开发者在本地的security/serializ...

gitblog_00170的博客 517

Dubbo——序列化(Serialize)协议原理

摘要 Dubbo 就依靠 SPI 机制实现了插件化功能,几乎将所有的功能组件做成基于 SPI 实现,并且默认提供了很多可以直接使用的扩展点,实现了面向功能进行拆分的对扩展开放的架构。 什么是 SPI SPI (Service Provider Interface),主要是用来在框架中使用的,最常见和莫过于我们在访问数据库时候用到的java.sql.Driver接口了。你想一下首先市面上的数据库五花八门,不同的数据库底层协议的大不相同,所以首先需要定制一个接口,来约束一下这些数据库,使得 Java 语言

庄小焱 4036

Dubbo源码分析系列之-整体架构设计

导语:   在了解一个框架的源码的时候,第一步要了解的就是源码的结构,接下来第二步需要了解的就是源码的架构,下面这张图在Dubbo官网上所展示的Dubbo的架构设计图。接下来就来详细的分析一下这张图。 整体说明   从左右颜色的角度分析,浅蓝色的表示Consumer也就是服务消费者,浅绿色的表示Provider也就是服务提供者,这个是左右分离的越往两边说明对于服务提供者和服务消费者的调用越强...

初学者 3279
上一篇: 分布式锁与实现--基于ZooKeeper实现
下一篇: 基于Flink流处理的动态实时电商实时分析系统
java_66666
博客等级 码龄10年 339粉丝 42原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值