ReferenceCountExchangeClient：将请求交HeaderExchangeClient处理，不进行任何其他操作。
public ResponseFuture request(Object request) throws RemotingException {
return client.request(request);
}
HeaderExchangeClient：提供心跳检查功能；将send、request、close等事件转由HeaderExchangeChannel处理，HeaderExchangeChannel对象中的Channel为所选的NIO框架对应的client对象；以request为例，调用流程如下：HeaderExchangeClient.request(Object request)->HeaderExchangeChannel.request(Object request)->(NettyClient)AbstractPeer.send(Object message)->(NettyClient)AbstractClient.send(Object message,boolean sent)。
public ResponseFuture request(Object request) throws RemotingException {
return channel.request(request);//HeaderExchangeChannel
}
HeaderExchangeChannel：主要是完成同步转异步，在request(Object request,int timeout)方法中，将请求转换成Request对象，将请求消息设置到data属性上，构建DefaultFuture对象，调用NIO框架对应的Client对象（默认NettyClient）的send方法将消息发送出去，返回DefultFuture对象。
public ResponseFuture request(Object request, int timeout) throws RemotingException {
if (closed) {
throw new RemotingException(this.getLocalAddress(), null, "Failed to send request " + request + ", cause: The channel " + this + " is closed!");
}
// create request.
Request req = new Request();
req.setVersion("2.0.0");
req.setTwoWay(true);
req.setData(request);
DefaultFuture future = new DefaultFuture(channel, req, timeout);
try{
channel.send(req);
}catch (RemotingException e) {
future.cancel();
throw e;
}
return future;
}
NettyClient：完成消息的发送。在调用链的最后一个方法AbstractClient.send(Object message, boolean sent)中，首先通过调用NettyClient.getChannel()获取NettyChannel对象，在构建对象时封装了NIOSocketChannel对象（在初始化NettyClient对象时，根据nettyclient和server端建立连接时获取的socket通道）、统一数据模型URL以及channelHandler对象（NettyClient对象自身），然后调用NettyChannel对象的send方法，将Request消息写入NIOSocketChannel通道中，完成消息发送。
public void send(Object message, boolean sent) throws RemotingException {//AbstractClient
if (send_reconnect && !isConnected()){
connect();
}
Channel channel = getChannel();
//TODO getChannel返回的状态是否包含null需要改进
if (channel == null || ! channel.isConnected()) {
throw new RemotingException(this, "message can not send, because channel is closed . url:" + getUrl());
}
channel.send(message, sent);
}
@Override
protected com.sitech.hsf.remoting.Channel getChannel() {//nettyclient
Channel c = channel;
if (c == null || ! c.isConnected())
return null;
return NettyChannel.getOrAddChannel(c, getUrl(), this);
}
public void send(Object message, boolean sent) throws RemotingException {//NettyChannel
super.send(message, sent);
boolean success = true;
int timeout = 0;
try {//调用Netty框架
ChannelFuture future = channel.write(message);
if (sent) {//sent=true等待发送失败将抛出异常，false不等待消息发出，将消息放入IO队列，即刻返回。
timeout = getUrl().getPositiveParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
success = future.await(timeout);
}
Throwable cause = future.getCause();
if (cause != null) {
throw cause;
}
} catch (Throwable e) {
throw new RemotingException(this, "Failed to send message " + message + " to " + getRemoteAddress() + ", cause: " + e.getMessage(), e);
}
if(! success) {
throw new RemotingException(this, "Failed to send message " + message + " to " + getRemoteAddress()
+ "in timeout(" + timeout + "ms) limit");
}
}
HeaderExchangeServer：提供心跳检查功能；启动心跳监测线程池，该线程初始化了一个线程，在线程中调用类HeartBeatTask进行心跳检查，HeartBeatTask处理心跳的规则：
（1）若通道的最新的写入时间或者最新的读取时间与当前时间相比，已经超过了心跳间隔时间，则发送心跳请求；
（2）如果通道的最新的读取时间与当前时间相比，已经超过了心跳的超时时间，对于客户端来说则重连，对于服务端来说则关闭通道。
public HeaderExchangeServer(Server server) {
if (server == null) {
throw new IllegalArgumentException("server == null");
}
this.server = server;
this.heartbeat = server.getUrl().getParameter(Constants.HEARTBEAT_KEY, 0);//
this.heartbeatTimeout = server.getUrl().getParameter(Constants.HEARTBEAT_TIMEOUT_KEY, heartbeat * 3);
if (heartbeatTimeout < heartbeat * 2) {
throw new IllegalStateException("heartbeatTimeout < heartbeatInterval * 2");
}
startHeatbeatTimer();
}3位心跳时长为心跳超时，如果不设置，默认心跳为0。
private void startHeatbeatTimer() {//HeaderExchangeServer
stopHeartbeatTimer();
if (heartbeat > 0) {
heatbeatTimer = scheduled.scheduleWithFixedDelay(
new HeartBeatTask( new HeartBeatTask.ChannelProvider() {
public Collection<Channel> getChannels() {
return Collections.unmodifiableCollection(
HeaderExchangeServer.this.getChannels() );
}
}, heartbeat, heartbeatTimeout),
heartbeat, heartbeat,TimeUnit.MILLISECONDS);
}
}
如果心跳为0，不执行心跳检测功能。
public void run() {//HeartBeatTask
try {
long now = System.currentTimeMillis();//获取当前时间
for ( Channel channel : channelProvider.getChannels() ) {
if (channel.isClosed()) {//已经关闭了
continue;
}
try {
//最后一次读的时间戳
Long lastRead = ( Long ) channel.getAttribute(
HeaderExchangeHandler.KEY_READ_TIMESTAMP );
//最后一次写的时间戳
Long lastWrite = ( Long ) channel.getAttribute(
HeaderExchangeHandler.KEY_WRITE_TIMESTAMP );
//如果当前时间距离最后一次写或读超过一个心跳时间
if ( ( lastRead != null && now - lastRead > heartbeat )
|| ( lastWrite != null && now - lastWrite > heartbeat ) ) {
Request req = new Request();
req.setVersion( "2.0.0" );
req.setTwoWay( true );
req.setEvent( Request.HEARTBEAT_EVENT );
channel.send( req );
if ( logger.isDebugEnabled() ) {
logger.debug( "Send heartbeat to remote channel " + channel.getRemoteAddress()
+ ", cause: The channel has no data-transmission exceeds a heartbeat period: " + heartbeat + "ms" );
}
}
//如果上一次读距离现在已经超过心路超时时长，尝试重连
if ( lastRead != null && now - lastRead > heartbeatTimeout ) {
logger.warn( "Close channel " + channel
+ ", because heartbeat read idle time out: " + heartbeatTimeout + "ms" );
if (channel instanceof Client) {
try {
((Client)channel).reconnect();
}catch (Exception e) {
//do nothing
}
} else {
channel.close();
}
}
} catch ( Throwable t ) {
logger.warn( "Exception when heartbeat to remote channel " + channel.getRemoteAddress(), t );
}
}
} catch ( Throwable t ) {
logger.warn( "Unhandled exception when heartbeat, cause: " + t.getMessage(), t );
}
}
在起动NettyClient和NettyServer连接时，都添加了一个HeartbeatHandler
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);
if(logger.isDebugEnabled()) {
logger.debug("Received heartbeat from remote channel " + channel.getRemoteAddress()
+ ", cause: The channel has no data-transmission exceeds a heartbeat period"
+ (heartbeat > 0 ? ": " + heartbeat + "ms" : ""));
}
}
}
return;
}
if (isHeartbeatResponse(message)) {//如果是心跳响应
if (logger.isDebugEnabled()) {
logger.debug(
new StringBuilder(32)
.append("Receive heartbeat response in thread ")
.append(Thread.currentThread().getName())
.toString());
}
return;
}
handler.received(channel, message);
}
多线程并发请求与单一长连接
如果客户端多线程并发请求的话，服务端通过单一长连接接受并返回响应信息，如果客户端不加控制就会导制通道中的数据变成无序，无法正确的处理请求。为此，Dubbo给每个请求添加一个唯一的标识ID，服务端响应请求也要携带此ID，供客户端多线程领取对应的响应数据，主要采用多线程编程中的Future模式来解决此问题。客户端的实现具体如下：
（1）当客户端发起远程请求时，最终调用HeaderExchangeClient.request方法，在该方法中调用HeaderExchangeChannel.request方法，并返回DefaultFutrue对象。首先创建Request对象，请求消息作为Data值，并创建唯一标识ID；然后在初始化DefaultFuture对象的过程中，将自身this对象以及channel对象存入全局变量DefaultFuture.FUTURES：ConcurrenthashMap和DefaultFuture.CHANNELS:ConcurrentHashMap中，以标识ID为key。
public ResponseFuture request(Object request, int timeout) throws RemotingException {//HeaderExchangeChannel.request
if (closed) {
throw new RemotingException(this.getLocalAddress(), null, "Failed to send request " + request + ", cause: The channel " + this + " is closed!");
}
// create request.
Request req = new Request();
req.setVersion("2.0.0");
req.setTwoWay(true);
req.setData(request);
DefaultFuture future = new DefaultFuture(channel, req, timeout);
try{
channel.send(req);
}catch (RemotingException e) {
future.cancel();
throw e;
}
return future;
}（2）该方法返回DefaultFuture对象给客户端线程，该线程会在DefaultFuture对象的get方法上面阻塞，有两种情况唤醒该线程：（一）接收到响应消息并调用received方法，根据响应消息中返回的ID从前面的ConcurrentHashMap里面get(ID)里面获取DefaultFuture对象，然后更新该对象的Response变量值。（二）RemotingInvocationTimeoutScan线程，定时扫描响应是否超时，若超时，则从FUTURES:ConcurrentHashMap中删除掉Future对象并且将Response变量设置为超时信息。
同步转异步的逻辑
<dubbo:method>标签中async属性表示是否异步招待；oninvoke表示方法执行前的拦截方法，onreturn表示方法执行返回后的拦截方法，onthrow表示方法执行有异常的拦截方法。
FutureFilter为客户端的过滤器，只有客户端才使用该过过滤器。在FutureFilter的invoke方法中，首先调用oninvoker属性配置的方法，然后调用invoker链的invoke方法，最后调用onreturn和onthrow配置的方法。
（1）当async=true时表示异步执行，获取本地线程类ThreadLocal<RpcContetext>的DefaultFuture对象，设置回调用类callback(该回调用类实现了ResponseCallback接口的done和caught方法)，在DefaultFuture对象中若收到响应之后调用回调用类的done方法。该done方法中调用客户端配置的onreturn和onthrow方法。
（2）当async=false时表示由不，在调用完invoker链的invoke方法后继续用客户端配置的onreturn和onthrow方法。
最后欢迎大家访问我的个人网站：1024s
扫一扫
2024
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
