[编织消息框架][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;
     }

 }

QException

接下来应用异常

首先要找到所有业务调用的主入口,由于用的是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);
     }
  }