Dubbo笔记衍生篇④：ChannelHandler

最新推荐文章于 2024-03-25 20:10:07 发布
最新推荐文章于 2024-03-25 20:10:07 发布
阅读量775 收藏
点赞数
分类专栏： # Dubbo 笔记衍生篇 文章标签： dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36882793/article/details/115725345
版权

文章目录

一、前言

本系列为个人Dubbo学习笔记衍生篇，是正文篇之外的衍生内容，内容来源于《深度剖析Apache Dubbo 核心技术内幕》, 过程参考官方源码分析文章。仅用于个人笔记记录。本文分析基于Dubbo2.7.0版本，由于个人理解的局限性，若文中不免出现错误，感谢指正。

本文为 Dubbo笔记⑦ : 服务提供方处理请求 衍生篇，内容为简单，仅分析内容比较简单，主要目的仅为梳理 ChannelHandler 的调用顺序。

二、ChannelHandler

ChannelHandler 是 Dubbo 提供的 SPI 接口，见名知意，该接口的作用是当服务消费者调用服务提供者的服务时，提供者用来处理各个消息事件。

ChannelHandler 接口如下：

@SPI
public interface ChannelHandler {

    /**
     * on channel connected.
     *
     * @param channel channel.
     */
    void connected(Channel channel) throws RemotingException;

    /**
     * on channel disconnected.
     *
     * @param channel channel.
     */
    void disconnected(Channel channel) throws RemotingException;

    /**
     * on message sent.
     *
     * @param channel channel.
     * @param message message.
     */
    void sent(Channel channel, Object message) throws RemotingException;

    /**
     * on message received.
     *
     * @param channel channel.
     * @param message message.
     */
    void received(Channel channel, Object message) throws RemotingException;

    /**
     * on exception caught.
     *
     * @param channel   channel.
     * @param exception exception.
     */
    void caught(Channel channel, Throwable exception) throws RemotingException;

}

而在Dubbo的实际调用过程中，当消费者调用服务提供者的服务时会发送Netty消息 (我们这里假设使用Netty 建立的服务)，服务提供者接收到Netty消息后会按照下图的流程一层一层执行，最终的消息交由DubboProtocol中的 requestHandler 来处理。

在这里插入图片描述

1. AbstractChannelHandlerDelegate

首先我们需要看一下AbstractChannelHandlerDelegate 的实现，AbstractChannelHandlerDelegate 是一个抽象实现类，其作用就是将事件委托给 handler来处理。下面的各种ChannelHandler 都是该类的实现类。

public abstract class AbstractChannelHandlerDelegate implements ChannelHandlerDelegate {

    protected ChannelHandler handler;

    protected AbstractChannelHandlerDelegate(ChannelHandler handler) {
        Assert.notNull(handler, "handler == null");
        this.handler = handler;
    }

    @Override
    public ChannelHandler getHandler() {
        if (handler instanceof ChannelHandlerDelegate) {
            return ((ChannelHandlerDelegate) handler).getHandler();
        }
        return handler;
    }

    @Override
    public void connected(Channel channel) throws RemotingException {
        handler.connected(channel);
    }

    @Override
    public void disconnected(Channel channel) throws RemotingException {
        handler.disconnected(channel);
    }

    @Override
    public void sent(Channel channel, Object message) throws RemotingException {
        handler.sent(channel, message);
    }

    @Override
    public void received(Channel channel, Object message) throws RemotingException {
        handler.received(channel, message);
    }

    @Override
    public void caught(Channel channel, Throwable exception) throws RemotingException {
        handler.caught(channel, exception);
    }
}

二、ChannelHandler 的调用栈

下面我们按照顺序依次来看一下 ChannelHandler 的调用栈。

1. MultiMessageHandler

MultiMessageHandler 仅仅针对了 received 方法做了处理，对 MultiMessage 消息类型进行了支持。如下：

public class MultiMessageHandler extends AbstractChannelHandlerDelegate {

    public MultiMessageHandler(ChannelHandler handler) {
        super(handler);
    }

    @SuppressWarnings("unchecked")
    @Override
    public void received(Channel channel, Object message) throws RemotingException {
        if (message instanceof MultiMessage) {
            MultiMessage list = (MultiMessage) message;
            for (Object obj : list) {
                handler.received(channel, obj);
            }
        } else {
            handler.received(channel, message);
        }
    }
}

2. HeartbeatHandler

HeartbeatHandler 实现的功能也很简单，记录通道的读写时间戳，仅仅对于 received 方法中的心跳消息做了特殊处理。

public class HeartbeatHandler extends AbstractChannelHandlerDelegate {

    private static final Logger logger = LoggerFactory.getLogger(HeartbeatHandler.class);

    public static String KEY_READ_TIMESTAMP = "READ_TIMESTAMP";

    public static String KEY_WRITE_TIMESTAMP = "WRITE_TIMESTAMP";

    public HeartbeatHandler(ChannelHandler handler) {
        super(handler);
    }

    @Override
    public void connected(Channel channel) throws RemotingException {
    	// 设置读写时间戳
        setReadTimestamp(channel);
        setWriteTimestamp(channel);
        handler.connected(channel);
    }

    @Override
    public void disconnected(Channel channel) throws RemotingException {
        clearReadTimestamp(channel);
        clearWriteTimestamp(channel);
        handler.disconnected(channel);
    }

    @Override
    public void sent(Channel channel, Object message) throws RemotingException {
        setWriteTimestamp(channel);
        handler.sent(channel, message);
    }

    @Override
    public void received(Channel channel, Object message) throws RemotingException {
    	// 设置读事件时间戳
        setReadTimestamp(channel);
        // 如果是心跳消息
        if (isHeartbeatRequest(message)) {
            Request req = (Request) message;
            // 如果需要返回消息
            if (req.isTwoWay()) {
            	// 设置消息内容并返回。
                Response res = new Response(req.getId(), req.getVersion());
                // 设置事件类型为心跳事件
                res.setEvent(Response.HEARTBEAT_EVENT);
                // 将消息内容发送回去
                channel.send(res);
                if (logger.isInfoEnabled()) {
                    int heartbeat = channel.getUrl().getParameter(Constants.HEARTBEAT_KEY, 0);
                  	// ... 日志打印
                }
            }
            return;
        }
        // 如果是心跳回复消息直接返回。
        if (isHeartbeatResponse(message)) {
            // ... 日志打印
            return;
        }
        // 正常处理 received 消息
        handler.received(channel, message);
    }

	....
}

3. AllChannelHandler

这一层实际是 Dubbo的线程模型层，默认情况下线程模型是all，其对应的处理类是 AllChannelHandler。如果指定了其他的线程模型则由其他类来处理。
关于 Dubbo线程模型

具体对应关系如下：

all=org.apache.dubbo.remoting.transport.dispatcher.all.AllDispatcher
direct=org.apache.dubbo.remoting.transport.dispatcher.direct.DirectDispatcher
message=org.apache.dubbo.remoting.transport.dispatcher.message.MessageOnlyDispatcher
execution=org.apache.dubbo.remoting.transport.dispatcher.execution.ExecutionDispatcher
connection=org.apache.dubbo.remoting.transport.dispatcher.connection.ConnectionOrderedDispatcher

AllChannelHandler 的具体实现如下(这里需要注意的是 ：WrappedChannelHandler#sent 并没有被 AllChannelHandler 重写，也即是说 sent 事件是由I/O线程来完成的，和官方文档描述的不同)：

// org.apache.dubbo.remoting.transport.dispatcher.all.AllChannelHandler
public class AllChannelHandler extends WrappedChannelHandler {

    public AllChannelHandler(ChannelHandler handler, URL url) {
        super(handler, url);
    }
	// 链接完成事件，交由线程池来处理
    @Override
    public void connected(Channel channel) throws RemotingException {
    	// 获取业务线程池
        ExecutorService cexecutor = getExecutorService();
        try {
        	// 将事件投递给业务线程池来处理。
            cexecutor.execute(new ChannelEventRunnable(channel, handler, ChannelState.CONNECTED));
        } catch (Throwable t) {
            throw new ExecutionException("connect event", channel, getClass() + " error when process connected event .", t);
        }
    }
	// 链接断开事件
    @Override
    public void disconnected(Channel channel) throws RemotingException {
        ExecutorService cexecutor = getExecutorService();
        try {
            cexecutor.execute(new ChannelEventRunnable(channel, handler, ChannelState.DISCONNECTED));
        } catch (Throwable t) {
            throw new ExecutionException("disconnect event", channel, getClass() + " error when process disconnected event .", t);
        }
    }
	// 请求响应事件
    @Override
    public void received(Channel channel, Object message) throws RemotingException {
        ExecutorService cexecutor = getExecutorService();
        try {
            cexecutor.execute(new ChannelEventRunnable(channel, handler, ChannelState.RECEIVED, message));
        } catch (Throwable t) {
        	if(message instanceof Request && t instanceof RejectedExecutionException){
        		Request request = (Request)message;
        		// 如果消息需要回复，则回复错误信息。
        		if(request.isTwoWay()){
        			String msg = "Server side(" + url.getIp() + "," + url.getPort() + ") threadpool is exhausted ,detail msg:" + t.getMessage();
        			Response response = new Response(request.getId(), request.getVersion());
        			response.setStatus(Response.SERVER_THREADPOOL_EXHAUSTED_ERROR);
        			response.setErrorMessage(msg);
        			channel.send(response);
        			return;
        		}
        	}
            throw new ExecutionException(message, channel, getClass() + " error when process received event .", t);
        }
    }
	
	// 异常处理事件
    @Override
    public void caught(Channel channel, Throwable exception) throws RemotingException {
        ExecutorService cexecutor = getExecutorService();
        try {
            cexecutor.execute(new ChannelEventRunnable(channel, handler, ChannelState.CAUGHT, exception));
        } catch (Throwable t) {
            throw new ExecutionException("caught event", channel, getClass() + " error when process caught event .", t);
        }
    }
}

在上面我们可以看到，事件被封装成了 ChannelEventRunnable 投递到线程池中，我们下面来看看 ChannelEventRunnable 的实现，由于 ChannelEventRunnable 实现了 Runnable 接口，我们这里只需要关注 ChannelEventRunnable#run方法即可：

    @Override
    public void run() {
    	// 检测通道状态，对于请求或响应消息，此时 state = RECEIVED。
        if (state == ChannelState.RECEIVED) {
            try {
            	//  将 channel 和 message 传给 ChannelHandler 对象，进行后续的调用
                handler.received(channel, message);
            } catch (Exception e) {
                logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel
                        + ", message is " + message, e);
            }
        } else {
        	 // 其他消息类型通过 switch 进行处理
            switch (state) {
            case CONNECTED:
                try {
                    handler.connected(channel);
                } catch (Exception e) {
                    logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel, e);
                }
                break;
            case DISCONNECTED:
                try {
                    handler.disconnected(channel);
                } catch (Exception e) {
                    logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel, e);
                }
                break;
            case SENT:
                try {
                    handler.sent(channel, message);
                } catch (Exception e) {
                    logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel
                            + ", message is " + message, e);
                }
                break;
            case CAUGHT:
                try {
                    handler.caught(channel, exception);
                } catch (Exception e) {
                    logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel
                            + ", message is: " + message + ", exception is " + exception, e);
                }
                break;
            default:
                logger.warn("unknown state: " + state + ", message is " + message);
            }
        }

    }

如上，请求和响应消息出现频率明显比其他类型消息高，所以这里对该类型的消息进行了针对性判断。ChannelEventRunnable 仅是一个中转站，它的 run 方法中并不包含具体的调用逻辑，仅用于将参数传给其他 ChannelHandler 对象进行处理，该对象类型为 DecodeHandler。

4. DecodeHandler

DecodeHandler 主要是包含了一些解码逻辑。DecodeHandler 存在的意义就是保证请求或响应对象可在线程池中被解码。解码完毕后，完全解码后的 Request 对象会继续向后传递。

public class DecodeHandler extends AbstractChannelHandlerDelegate {

    private static final Logger log = LoggerFactory.getLogger(DecodeHandler.class);

    public DecodeHandler(ChannelHandler handler) {
        super(handler);
    }

    @Override
    public void received(Channel channel, Object message) throws RemotingException {
        if (message instanceof Decodeable) {
        	// 对 Decodeable 接口实现类对象进行解码
            decode(message);
        }

        if (message instanceof Request) {
        	 // 对 Request 的 data 字段进行解码
            decode(((Request) message).getData());
        }

        if (message instanceof Response) {
        	 // 对 Request 的 result 字段进行解码
            decode(((Response) message).getResult());
        }

        handler.received(channel, message);
    }

    private void decode(Object message) {
        // Decodeable 接口目前有两个实现类，
        // 分别为 DecodeableRpcInvocation 和 DecodeableRpcResult
        if (message != null && message instanceof Decodeable) {
            try {
        		// 执行解码逻辑
                ((Decodeable) message).decode();
                if (log.isDebugEnabled()) {
                    log.debug("Decode decodeable message " + message.getClass().getName());
                }
            } catch (Throwable e) {
                if (log.isWarnEnabled()) {
                    log.warn("Call Decodeable.decode failed: " + e.getMessage(), e);
                }
            } // ~ end of catch
        } // ~ end of if
    } // ~ end of method decode

}

如有需要，详参 ： Dubbo笔记 ㉓ ：Dubbo协议与网络传输

5. HeaderExchangeHandler

对于双向通信，HeaderExchangeHandler 首先向后进行调用，得到调用结果。然后将调用结果封装到 Response 对象中，最后再将该对象返回给服务消费方。如果请求不合法，或者调用失败，则将错误信息封装到 Response 对象中，并返回给服务消费方。接下来我们继续向后分析，把剩余的调用过程分析完。下面分析定义在 DubboProtocol 类中的匿名类对象逻辑，如下：

public class HeaderExchangeHandler implements ChannelHandlerDelegate {

    protected static final Logger logger = LoggerFactory.getLogger(HeaderExchangeHandler.class);

    public static String KEY_READ_TIMESTAMP = HeartbeatHandler.KEY_READ_TIMESTAMP;

    public static String KEY_WRITE_TIMESTAMP = HeartbeatHandler.KEY_WRITE_TIMESTAMP;

    private final ExchangeHandler handler;

    public HeaderExchangeHandler(ExchangeHandler handler) {
        if (handler == null) {
            throw new IllegalArgumentException("handler == null");
        }
        this.handler = handler;
    }
	// 处理返回消息
    static void handleResponse(Channel channel, Response response) throws RemotingException {
        if (response != null && !response.isHeartbeat()) {
            DefaultFuture.received(channel, response);
        }
    }
	// 是否是客户端
    private static boolean isClientSide(Channel channel) {
        InetSocketAddress address = channel.getRemoteAddress();
        URL url = channel.getUrl();
        return url.getPort() == address.getPort() &&
                NetUtils.filterLocalHost(url.getIp())
                        .equals(NetUtils.filterLocalHost(address.getAddress().getHostAddress()));
    }

 	void handlerEvent(Channel channel, Request req) throws RemotingException {
    	// 如果是只读事件，设置通道为只读
        if (req.getData() != null && req.getData().equals(Request.READONLY_EVENT)) {
            channel.setAttribute(Constants.CHANNEL_ATTRIBUTE_READONLY_KEY, Boolean.TRUE);
        }
    }

 	void handleRequest(final ExchangeChannel channel, Request req) throws RemotingException {
 		
        Response res = new Response(req.getId(), req.getVersion());
        // 检测请求是否合法，不合法则返回状态码为 BAD_REQUEST 的响应
        if (req.isBroken()) {
            Object data = req.getData();

            String msg;
            if (data == null) {
                msg = null;
            } else if (data instanceof Throwable) {
                msg = StringUtils.toString((Throwable) data);
            } else {
                msg = data.toString();
            }
            res.setErrorMessage("Fail to decode request due to: " + msg);
             // 设置 BAD_REQUEST 状态
            res.setStatus(Response.BAD_REQUEST);

            channel.send(res);
            return;
        }
        // find handler by message class.
         // 获取 data 字段值，也就是 RpcInvocation 对象
        Object msg = req.getData();
        try {
            // handle data.
             // 继续向下调用， 这里调用的是 replay 方法
            CompletableFuture<Object> future = handler.reply(channel, msg);
            // 如果请求已经完成则写回结果
            if (future.isDone()) {
                res.setStatus(Response.OK);
                res.setResult(future.get());
                channel.send(res);
                return;
            }
            // 如果还没完成，则等待结束后写回结果
            future.whenComplete((result, t) -> {
                try {
                    if (t == null) {
                        res.setStatus(Response.OK);
                        res.setResult(result);
                    } else {
                        res.setStatus(Response.SERVICE_ERROR);
                        res.setErrorMessage(StringUtils.toString(t));
                    }
                    channel.send(res);
                } catch (RemotingException e) {
                    logger.warn("Send result to consumer failed, channel is " + channel + ", msg is " + e);
                } finally {
                    // HeaderExchangeChannel.removeChannelIfDisconnected(channel);
                }
            });
        } catch (Throwable e) {
            res.setStatus(Response.SERVICE_ERROR);
            res.setErrorMessage(StringUtils.toString(e));
            channel.send(res);
        }
    }

    @Override
    public void connected(Channel channel) throws RemotingException {
        channel.setAttribute(KEY_READ_TIMESTAMP, System.currentTimeMillis());
        channel.setAttribute(KEY_WRITE_TIMESTAMP, System.currentTimeMillis());
        ExchangeChannel exchangeChannel = HeaderExchangeChannel.getOrAddChannel(channel);
        try {
            handler.connected(exchangeChannel);
        } finally {
            HeaderExchangeChannel.removeChannelIfDisconnected(channel);
        }
    }

    @Override
    public void disconnected(Channel channel) throws RemotingException {
        channel.setAttribute(KEY_READ_TIMESTAMP, System.currentTimeMillis());
        channel.setAttribute(KEY_WRITE_TIMESTAMP, System.currentTimeMillis());
        ExchangeChannel exchangeChannel = HeaderExchangeChannel.getOrAddChannel(channel);
        try {
            handler.disconnected(exchangeChannel);
        } finally {
            DefaultFuture.closeChannel(channel);
            HeaderExchangeChannel.removeChannelIfDisconnected(channel);
        }
    }

    @Override
    public void sent(Channel channel, Object message) throws RemotingException {
        Throwable exception = null;
        try {
            channel.setAttribute(KEY_WRITE_TIMESTAMP, System.currentTimeMillis());
            ExchangeChannel exchangeChannel = HeaderExchangeChannel.getOrAddChannel(channel);
            try {
                handler.sent(exchangeChannel, message);
            } finally {
                HeaderExchangeChannel.removeChannelIfDisconnected(channel);
            }
        } catch (Throwable t) {
            exception = t;
        }
        if (message instanceof Request) {
            Request request = (Request) message;
            DefaultFuture.sent(channel, request);
        }
        if (exception != null) {
            if (exception instanceof RuntimeException) {
                throw (RuntimeException) exception;
            } else if (exception instanceof RemotingException) {
                throw (RemotingException) exception;
            } else {
                throw new RemotingException(channel.getLocalAddress(), channel.getRemoteAddress(),
                        exception.getMessage(), exception);
            }
        }
    }

   @Override
    public void received(Channel channel, Object message) throws RemotingException {
    	// 记录通道读的时间戳
        channel.setAttribute(KEY_READ_TIMESTAMP, System.currentTimeMillis());
        final ExchangeChannel exchangeChannel = HeaderExchangeChannel.getOrAddChannel(channel);
        try {
        	// 如果是请求类型消息
            if (message instanceof Request) {
                // handle request.
                // 处理请求
                Request request = (Request) message;
                if (request.isEvent()) {
                	// 处理事件对象
                    handlerEvent(channel, request);
                } else {
                	// 如果需要有返回值的请求req-res,twoway，此时为双向通信，需要获取调用结果并返回给服务消费端
                    if (request.isTwoWay()) {
                        handleRequest(exchangeChannel, request);
                    } else {
                    	// 不需要有返回值的请求 req, oneway，此时为单向通信，仅向后调用指定服务即可，无需返回调用结果
                        handler.received(exchangeChannel, request.getData());
                    }
                }
            } else if (message instanceof Response) {	// 响应消息，服务消费方会执行此处逻辑
                handleResponse(channel, (Response) message);
            } else if (message instanceof String) {
	            // telnet 相关	
                if (isClientSide(channel)) {
                    Exception e = new Exception("Dubbo client can not supported string message: " + message + " in channel: " + channel + ", url: " + channel.getUrl());
                    logger.error(e.getMessage(), e);
                } else {
                    String echo = handler.telnet(channel, (String) message);
                    if (echo != null && echo.length() > 0) {
                        channel.send(echo);
                    }
                }
            } else {
                handler.received(exchangeChannel, message);
            }
        } finally {
            HeaderExchangeChannel.removeChannelIfDisconnected(channel);
        }
    }

    @Override
    public void caught(Channel channel, Throwable exception) throws RemotingException {
        if (exception instanceof ExecutionException) {
            ExecutionException e = (ExecutionException) exception;
            Object msg = e.getRequest();
            if (msg instanceof Request) {
                Request req = (Request) msg;
                if (req.isTwoWay() && !req.isHeartbeat()) {
                    Response res = new Response(req.getId(), req.getVersion());
                    res.setStatus(Response.SERVER_ERROR);
                    res.setErrorMessage(StringUtils.toString(e));
                    channel.send(res);
                    return;
                }
            }
        }
        ExchangeChannel exchangeChannel = HeaderExchangeChannel.getOrAddChannel(channel);
        try {
            handler.caught(exchangeChannel, exception);
        } finally {
            HeaderExchangeChannel.removeChannelIfDisconnected(channel);
        }
    }

    @Override
    public ChannelHandler getHandler() {
        if (handler instanceof ChannelHandlerDelegate) {
            return ((ChannelHandlerDelegate) handler).getHandler();
        } else {
            return handler;
        }
    }

6. DubboProtocol#requestHandler

DubboProtocol#requestHandler 是完成 Netty 消息处理的地方，关于该方法的分析，详参
Dubbo笔记⑦ : 服务提供方处理请求

以上：内容部分参考
《深度剖析Apache Dubbo 核心技术内幕》
https://dubbo.apache.org/zh/docs/v2.7/dev/source/
如有侵扰，联系删除。 内容仅用于自我记录学习使用。如有错误，欢迎指正

猫吻鱼
关注
专栏目录
Apache Dubbo：Dubbo服务治理：服务路由与动态配置
07-12
### Apache Dubbo：服务治理——服务路由与动态配置 #### 一、服务治理的重要性 在当前流行的微服务架构中，由于各个服务之间存在着频繁而复杂的交互，如何有效地管理和控制这些服务成为了确保整个系统稳定性和可...
Apache Dubbo：Dubbo服务治理：负载均衡与容错机制
07-12
### Apache Dubbo：Dubbo服务治理：负载均衡与容错机制 #### 一、Dubbo服务治理的重要性 在现代微服务架构中，服务间的交互变得日益频繁和复杂，因此需要一种有效的方式来管理这些服务，以确保整个系统的稳定性和...
【Dubbo】ChannelHandler 完整实现
菜鸡也有大佬梦
05-11 560
主要内容 ： 讲解 ChannelHandler，及其如何贯穿 Protocol -> Exchange -> Transport 层 ChannelHandler 如果读者熟悉 Netty 框架 ， 那么很容易理解 Dubbo 内部使用的 ChannlHandler 组件的原理,Dubbo 框架内部使用大量 Handler 组成类似链表 ， 依次处理具体逻辑 ， 比如编解码 、 心跳时间戳和方法调用 Handler 等 。 因为 Netty 每次创建 Handler 都会经过 Channe
Dubbo源码分析：ＣhannelHandler
weixin_30371875的博客
02-17 78
背景 一个请求经过序列化二进制数据转化成对象之后。请求进入netty框架，netty框架经过业务处理把主动权转交给NettyHandler对象。NettyHandler进入ChannelHandler机制的入口点。 类图 转载于:https://www.cnblogs.com/wspgbw/p/6409922.html...
深度解析dubbo网路传输层ChannelHandler
猿上生活
09-16 1029
本文基于dubbo v2.6.x 1. ChannelHandler ChannelHandler 是dubbo 对于Channel事件处理的抽象，它抽象了五个事件，分别是连接的时候，断开连接的时候，消息发送完成的时候，接收到消息的时候，发生异常的时候，我们来看下它的定义 @SPI public interface ChannelHandler { /** * on channel connected. * @param channel channel. */
聊聊dubbo的WrappedChannelHandler
chuoguo3754的博客
08-29 305
序 本文主要研究一下dubbo的WrappedChannelHandler WrappedChannelHandler dubbo-2.7.3/dubbo-remoting/dubbo-remoting-api/src/main/java/org/apache/dubbo/remoting/t...
Dubbo内部使用的ChannlHandler组件的原理还不懂吗？不懂的快来学
2401_83384536的博客
03-25 637
如果读者熟悉Netty框架，那么很容易理解Dubbo内部使用的ChannlHandler组件的原理,Dubbo框架内部使用大量Handler组成类似链表，依次处理具体逻辑，比如编解码、心跳时间戳和方法调用Handler等。因为Netty每次创建Handler都会经过ChannelPipeline,大量的事件经过很多Pipeline会有较多的开销，因此Dubbo会将多个Handler聚合为一个Handler。
Apache Dubbo：Dubbo高级特性：服务降级与熔断实战
最新发布
07-12
Apache Dubbo：Dubbo高级特性：服务降级与熔断实战 Dubbo是著名的RCP框架，文档内有干货，提供代码和可复现的命令，值得借鉴。
dubbo-hessian-lite:适用于Apache Dubbo的Hessian Lite
05-27
Hessian Lite（Apache Dubbo专用版） Hessian-lite最初是的Apache dubbo嵌入版本。 然后，此模块与Dubbo分离。 所有分支：2.5.x，2.6.x（自2.6.3起）和2.7.x都依赖于它，请查看详细信息： 现在，我们正在尝试建立一...
dubbo-php-framework:适用于Apache Dubbo的php
04-22
它与Dubbo协议完全兼容，并且可以同时用作提供商终端和消费者终端。 使用zookeeper进行服务注册发现，并使用fastjson和hessian进行序列化。 介绍 php provider在多个进程中运行。 工作进程用于处理特定的业务，管理...
dubbo中ChannelHandler说明
weixin_34417814的博客
09-28 447
为什么80%的码农都做不了架构师？>>> ...
ChannelHandler
04stone37
05-03 292
类体系线程安全　　ChannelHandler的线程安全性取决于具体的实现，如果线程安全则不同的ChannelPipeline间可以共享，避免每个Channel创建一个ChannelHandler实例；如果线程不安全，则需要为每个Channel创建一个ChannelHandler实例，避免锁竞争带来的损耗；
一次dubbo客户端消费者超时-线程池耗尽问题处理
eos2009的博客
10-21 4504
1、问题起因 上线一个文件下载服务，运行一直稳定，偶有异常（连接国外网络不稳定导致），一天突然消费端频繁抛出超时异常（不是所有请求都超时，大部分超时）， 起初以为下载文件过大导致超时，测试发现不是该问题（使用小文件测试），猜测可能是服务端出了问题 2、查看问题 查看服务端最近异常log，发现如下异常（异常信息从网上down的，不是原始信息，原始信息当时删了，懒得去找了。。） [DUBBO] An ...
聊聊dubbo的AllDispatcher
chuoguo3754的博客
08-31 437
序 本文主要研究一下dubbo的AllDispatcher Dispatcher dubbo-2.7.3/dubbo-remoting/dubbo-remoting-api/src/main/java/org/apache/dubbo/remoting/Dispatcher.java @SPI...
dubbo项目报错解决：com.alibaba.dubbo.remoting.ExecutionException 线程池爆满错误
危险、的博客
11-07 4573
com.alibaba.dubbo.remoting.ExecutionException: class com.alibaba.dubbo.remoting.transport.dispatcher.message.MessageOnlyChannelHandler error when process received event . at com.alibaba.dubbo.remoting...
Dubbo直连报错，已经解决
12-26 1442
第一个错 Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named ‘cacheManager’ available at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBeanDefinition(DefaultListableBeanFactory.java:687) at org.sp
dubbo调用 Caused by: com.alibaba.dubbo.remoting.RemotingException 异常解决方法
热门推荐
企业数字化转型服务提供商
10-30 5万+
Caused by: com.alibaba.dubbo.remoting.RemotingException: message can not send, because channel is closed . url:dubbo://192.168.199.170:20883/com.coracle.dms.service.DmsChannelContactsService?anyhost=t...
并发情况下dubbo链接数数不够
csdn952762369的博客
02-10 837
查看日志可以看到报错信息如下，说明是dubbo的提供者提供的链接数不够，默认是200个连接，需要扩大链接数 com.alibaba.dubbo.rpc.RpcException: Failed to invoke the method getProducts in the service com.learnling.provider.api.product.ProductApi. Tr...
解决dubbo不能优雅停机
m1993619的专栏
03-09 8431
摘要: 从源码角度解读为啥2.5.3版本不支持优雅停机，通过修改源码达到优雅停机现状dubbo-2.5.4以下的版本不支持优雅停机，是因为服务端关闭时，客户端主动关闭长连接，导致服务端响应消息不能返回。在服务端和客户端配置参数：-Ddubbo.service.shutdown.wait=30000，该参数为停机等待时间，但是结果也不生效，还是马上停机了。期望结果正在读或者写的消息，需要继续处理；线...
Dubbo集群调用策略详解：源码剖析与配置
在使用Dubbo时，可以通过配置`<dubbo:reference>`标签来指定集群策略（如`cluster="failsafe"`）和重试次数（`retries="2"`）。当遇到服务失败时，FailOver模式会尝试多次调用其他可用的服务提供者，直到达到指定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猫吻鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值