[编织消息框架][JAVA核心技术]异常应用

QException是项目业务异常基类 按模块划分子类异常，方便定位那块出错

有个来源码属性code作用定位某个功能处理出错逻辑，数字类型节省内存空间，同时减少创建子类的子类

QSocketException 是通信层出错 凡是来自QSocketException 统一认为非法请求，强制关闭socket连接

QJsonException 是json编解码出错 json很流行种数据格式，跨平台特点，经常处理

QEnhanceException 是Javassist动态生成java class技术，用于替换jdk 动态代理

public class QException extends RuntimeException {

    private static final long serialVersionUID = -3110633035340065406L;

    private short code;

    public short getCode() {
    return code;
    }

    public QException(short code, String message, Throwable cause) {
    super(message, cause);
    this.code = code;
    }

    public QException(short code) {
    super();
    this.code = code;
    }

    public QException(short code, String message) {
    super(message);
    this.code = code;
    }

}

接下来应用异常

首先要找到所有业务调用的主入口,由于用的是netty通信框架，对于服务端来讲要找到接收数据的方法

ChannelDuplexHandler 是netty提供的业务实现的类，其中channelRead是接收数据的方法

@Sharable
public class QMessageHandler extends ChannelDuplexHandler {

    private QDispenseHandler dispenseHandler;

    public QMessageHandler(QDispenseHandler dispenseHandler) {
        this.dispenseHandler = dispenseHandler;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        dispenseHandler.doConnect(ctx);
        super.channelActive(ctx);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        dispenseHandler.doReceive(msg, ctx);
        super.channelRead(ctx, msg);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        dispenseHandler.doClose(ctx);
        super.channelInactive(ctx);
    }
}

QDispenseHandler.class 

当业务处理失败时，响应三种策略

1.优先处理来自QSocketException强制关闭socket连接

2.业务边界QException

3.未知错误Exception

第一种情况不用返回响应码

第二三种情况是否返回根据客户端请求状态决定 boolean response = packet.hasStatus(QPacket.MASK_RESPONSE)

 public void doReceive(Object msg, ChannelHandlerContext ctx) {
    if (msg instanceof QPacket) {
        pool.execute(() -> {
        doReceive0((QPacket) msg, ctx);
        });
    }
 }

 private void doReceive0(QPacket packet, ChannelHandlerContext ctx) {

    boolean response = packet.hasStatus(QPacket.MASK_RESPONSE);
    try {
        //doReceive ... 处理省略细节
        
    } catch (QSocketException e) {
        // socket异常 关闭连接
        packet.responseCode(e.getCode());
        LOGGER.error("QSocketException  msg {} error : {}", QCodeUtil.getDes( e.getCode()), e);
        if (response) {
        ChannelFuture future = ctx.channel().writeAndFlush(packet);
        future.addListener(new GenericFutureListener<Future<? super Void>>() {
            @Override
            public void operationComplete(Future<? super Void> future) throws Exception {
            NettyUtil.closeChannel(CLOSE_SOURCE.SOCKET_ERROR, false, ctx.channel());
            }
        });
        } else {
        NettyUtil.closeChannel(CLOSE_SOURCE.SOCKET_ERROR, false, ctx.channel());
        }
        return;
    } catch (QException e) {
        // 业务异常 响应失败
        packet.responseCode(e.getCode());
        LOGGER.error("QException  msg {} error : {}",QCodeUtil.getDes( e.getCode()), e);
    } catch (Exception e) {
        // 未知异常 响应失败
        packet.responseCode(QCode.ERROR_UNKNOWN);
        LOGGER.error("UNKNOWNException  error : {}", e);
    }
    if (response) {
        ctx.channel().writeAndFlush(packet);
    }
 }