【Spring Boot】集成Netty Socket.IO通讯框架

服务端

 @Configuration
 public class NettySocketConfig {
 
     private static final Logger logger = LoggerFactory.getLogger(NettySocketConfig.class);
 
     @Bean
     public SocketIOServer socketIOServer() {
         //创建Socket，并设置监听端口
         com.corundumstudio.socketio.Configuration config = new com.corundumstudio.socketio.Configuration();
         // 设置主机名，默认是0.0.0.0
         config.setHostname("192.168.8.107");
         // 设置监听端口
         config.setPort(9096);
         // 协议升级超时时间（毫秒），默认10000。HTTP握手升级为ws协议超时时间
         config.setUpgradeTimeout(10000);
         // Ping消息间隔（毫秒），默认25000。客户端向服务器发送一条心跳消息间隔
         config.setPingInterval(60000);
         // Ping消息超时时间（毫秒），默认60000，这个时间间隔内没有接收到心跳消息就会发送超时事件
         config.setPingTimeout(180000);
         // 这个版本0.9.0不能处理好namespace和query参数的问题。所以为了做认证必须使用全局默认命名空间
         config.setAuthorizationListener(new AuthorizationListener() {
             @Override
             public boolean isAuthorized(HandshakeData data) {
                 // 可以使用如下代码获取用户密码信息
                 //String username = data.getSingleUrlParam("username");
                 //String password = data.getSingleUrlParam("password");
                 //logger.info("连接参数：username=" + username + ",password=" + password);
                 //ManagerInfo managerInfo = managerInfoService.findByUsername(username);
                 //
                 //String salt = managerInfo.getSalt();
                 //String encodedPassword = ShiroKit.md5(password, username + salt);
                 //// 如果认证不通过会返回一个Socket.EVENT_CONNECT_ERROR事件
                 //return encodedPassword.equals(managerInfo.getPassword());
 
                 return true;
             }
         });
 
         final SocketIOServer server = new SocketIOServer(config);
         System.out.println("注入SocketIOServer");
         return server;
     }
 
     @Bean
     public SpringAnnotationScanner springAnnotationScanner(SocketIOServer socketServer) {
         return new SpringAnnotationScanner(socketServer);
     }
 }

 @Component
 public class MessageEventHandler {
 
     private static final Logger logger = LoggerFactory.getLogger(MessageEventHandler.class);
 
     /**
      * 服务器socket对象
      */
     public static SocketIOServer socketIoServer;
 
     /**
      * 客户端集合
      */
     static ArrayList<UUID> listClient = new ArrayList<>();
 
     /**
      * 超时时间
      */
     static final int limitSeconds = 60;
 
     @Autowired
     public LoginService loginService;
 
     /**
      * 初始化消息事件处理器
      *
      * @param server 服务器socket对象
      */
     @Autowired
     public MessageEventHandler(SocketIOServer server) {
         logger.info("初始化SOCKET消息事件处理器");
         this.socketIoServer = server;
     }
 
     /**
      * 客户端发起连接时触发
      *
      * @param client 客户端Socket对象信息
      */
     @OnConnect
     public void onConnect(SocketIOClient client) {
         logger.info("客户端{}已连接", client.getSessionId());
         listClient.add(client.getSessionId());
     }
 
     /**
      * 客户端断开连接时触发
      *
      * @param client 客户端Socket对象信息
      */
     @OnDisconnect
     public void onDisconnect(SocketIOClient client) {
         logger.info("客户端{}断开连接", client.getSessionId());
         if (listClient.contains(client.getSessionId())) {
             listClient.remove(client.getSessionId());
         }
     }
 
     /**
      * 客户端发送消息时触发
      *
      * @param client  客户端Socket对象信息
      * @param request AckRequest 回调对象
      * @param data    消息信息实体
      */
     @OnEvent(value = SocketConstants.SocketEvent.MESSAGE)
     public void onEvent(SocketIOClient client, AckRequest request, MessageInfo data) {
         System.out.println("发来消息：" + data.getMsgContent());
         socketIoServer.getClient(client.getSessionId()).sendEvent("messageevent", "back data");
     }
 
     /**
      * 效验连接事件并存储客户端信息
      *
      * @param client  客户端Socket对象信息
      * @param data    客户端数据
      * @param request AckRequest 回调对象
      */
     @OnEvent(value = SocketConstants.SocketEvent.HEALTH_CHECK)
     public void onEventByHealthCheck(SocketIOClient client, String data, AckRequest request) {
         //logger.info("客户端{}效验连接请求", client.getSessionId());
         ////解析请求数据
         //HealthCheckRequest healthCheckRequest = JSON.parseObject(data, HealthCheckRequest.class);
         //if (healthCheckRequest != null) {
         //    //存储客户端信息
         //    SocketInstance instance = SocketInstance.getSocketInstance();
         //    System.out.println(data);
         //    instance.insertSocketClient(healthCheckRequest.getEnCode(), client);
         //    logger.info("客户端{}效验连接响应:{}", client.getSessionId(), "OK");
         //    //响应客户端
         //    request.sendAckData("OK");
         //}
     }
 
     /**
      * 登录事件
      *
      * @param client  客户端Socket对象信息
      * @param data    客户端数据
      * @param request AckRequest 回调对象
      */
     @OnEvent(value = SocketConstants.SocketEvent.LOGIN)
     public void onEventByLogin(SocketIOClient client, String data, AckRequest request) {
         logger.info("客户端{}登录请求:{}", client.getSessionId(), data);
         AppResponseBase appResponseBase = new AppResponseBase(0, "通讯成功");
         //业务响应对象
         LoginResponse loginResponse = null;
         try {
             //解析请求数据
             LoginRequest loginRequest = JSON.parseObject(data, LoginRequest.class);
             if (loginRequest == null) {
                 throw new AppException(AppResultCode.LoginAnalysis_Fail);
             }
             //调用登陆接口
             loginResponse = loginService.appLogin(loginRequest);
             if (loginResponse == null) {
                 throw new AppException(AppResultCode.LoginCloud_Fail);
             }
             if (EnumResult.Success.equals(loginResponse.getResultCode())) {
                 //保存客户端Socket信息
                 SocketInstance instance = SocketInstance.getSocketInstance();
                 instance.insertSocketClient(loginRequest.getEnCode(), client);
             }
         } catch (AppException ex) {
             loginResponse = new LoginResponse(ex.getAppResultCode().getCode(), ex.getAppResultCode().getMsg());
         } catch (Exception ex) {
             loginResponse = new LoginResponse(AppResultCode.Exceptions.getCode(), AppResultCode.Exceptions.getMsg());
             ex.printStackTrace();
         }
         appResponseBase.setRespData(loginResponse);
         String result = JSON.toJSONString(appResponseBase);
         logger.info("客户端{}登录响应:{}", client.getSessionId(), result);
         //响应客户端
         request.sendAckData(result);
     }
 
     /**
      * 交易下单事件
      * @param callPayRequest 下单请求信息实体
      * @return
      */
     public static String sendByPayEvent(CallPayRequest callPayRequest) {
         String result = "";
         //获取客户端信息
         SocketInstance instance = SocketInstance.getSocketInstance();
         SocketIOClient client = instance.getClientSocket(callPayRequest.getEnCode());
         if (client != null) {
             //请求报文
             String requestParam = JSON.toJSONString(callPayRequest);
             //请求下单
             client.sendEvent(SocketConstants.SocketEvent.PAY, new AckCallback<String>(String.class) {
                 @Override
                 public void onSuccess(String s) {
                     //响应信息
                     System.out.println("ack from client: " + client.getSessionId() + " data: " + s.toString());
                 }
             }, requestParam);
 
         } else {
             //客户端已断开连接
 
         }
         return result;
     }
 }

 @Component
 @Order(value = 1)
 public class MyCommandLineRunner implements CommandLineRunner {
 
     private final SocketIOServer server;
 
     @Autowired
     public MyCommandLineRunner(SocketIOServer server) {
         System.out.println("初始化MyCommandLineRunner");
         this.server = server;
     }
 
     @Override
     public void run(String... args) {
         try {
             server.start();
             System.out.println("socket.io启动成功！");
         } catch (Exception ex) {
             ex.printStackTrace();
         }
     }
 }

 public class SocketConstants {
 
     /**
      * Socket事件类
      */
     public class SocketEvent {
 
         /**
          * 效验连接状况
          */
         public static final String HEALTH_CHECK = "HEALTH_CHECK";
 
         /**
          * 消息接收事件名称
          */
         public static final String MESSAGE = "message";
 
         /**
          * 登录事件名称
          */
         public static final String LOGIN = "LOGIN";
 
         /**
          * 获取交易要素事件名称
          */
         public static final String QUERY_PAY_FIELDS = "QUERY_PAY_FIELDS";
 
         /**
          * 创建订单事件名称
          */
         public static final String CREATE_ORDER = "CREATE_ORDER";
 
         /**
          * 监控订单状态事件名称
          */
         public static final String CHECK_ORDER_STATUS = "CHECK_ORDER_STATUS";
 
         /**
          * 获取订单事件名称
          */
         public static final String QUERY_ORDER = "QUERY_ORDER";
 
         /**
          * 支付事件名称
          */
         public static final String PAY = "PAY";
     }
 }

 public class SocketInstance {
 
     /**
      * 客户端Socket连接对象容器
      */
     private static Map<String, SocketIOClient> socketClients = null;
 
     /**
      * 私有构造
      */
     private SocketInstance() {
         //从缓存中获取socketClients
         socketClients = new HashMap<>();
     }
 
     /**
      * 定义一个私有的内部类，在第一次用这个嵌套类时，会创建一个实例。而类型为SocketInstanceHolder的类，只有在SocketInstance.getSocketInstance()中调用，
      * 由于私有的属性，他人无法使用SocketInstanceHolder，不调用SocketInstance.getSocketInstance()就不会创建实例。
      * 优点：达到了lazy loading的效果，即按需创建实例。
      * 无法适用于分布式集群部署
      */
     private static class SocketInstanceHolder {
         /**
          * 创建全局唯一实例
          */
         private final static SocketInstance instance = new SocketInstance();
     }
 
     /**
      * 获取全局唯一实例
      *
      * @return SocketInstance对象
      */
     public static SocketInstance getSocketInstance() {
         return SocketInstanceHolder.instance;
     }
 
     /**
      * 新增客户端连接到容器
      *
      * @param encode         设备En号
      * @param socketIOClient 客户端socket对象
      */
     public void insertSocketClient(String encode, SocketIOClient socketIOClient) {
         SocketIOClient oldSocketIOClient = socketClients.get(encode);
         if (oldSocketIOClient != null) {
             try {
                 //关闭客户端连接
                 oldSocketIOClient.disconnect();
             } catch (Exception ex) {
                 ex.printStackTrace();
             }
         }
         socketClients.put(encode, socketIOClient);
     }
 
     /**
      * 获取客户端Socket对象
      *
      * @param encode 设备encode
      * @return 客户端Socket对象
      */
     public SocketIOClient getClientSocket(String encode) {
         return socketClients.get(encode);
     }
 }

Android客户端

 public class SocketClient {
 
     /**
      * 最大重连次数
      */
     private int maxReConnectionCount = 5;
 
     /**
      * 重连次数
      */
     private int reConnectionCount = 0;
 
     /**
      * 等待框对象
      */
     private static ProgressDialog progressdialog;
 
     /**
      * 提示框
      */
     private static AlertDialog.Builder dialogExitBuilder;
 
     /**
      * Toast提示对象
      */
     private static Toast toast;
 
     /**
      * Socket客户端对象信息
      */
     public static Socket socket;
 
     /**
      * 主页面对象，每个页面onCreate时必须设置，可在每个页面监控Socket连接状况
      */
     public static Context nowContext;
 
     /**
      * Socket连接提示handler(等待框)
      */
     Handler dialogMessageHandler = new Handler() {
         @Override
         public void handleMessage(Message msg) {
             super.handleMessage(msg);
             Bundle bundle = msg.getData();
             String message = bundle.getString(MessageUtil.MESSAGE);
             setDialogMessage(message);
         }
     };
 
     /**
      * Socket连接失败退出提示handler(提示框)
      */
     Handler dialogExitHandler = new Handler() {
         @Override
         public void handleMessage(Message msg) {
             super.handleMessage(msg);
             Bundle bundle = msg.getData();
             String message = bundle.getString(MessageUtil.MESSAGE);
             dialogExit(message);
         }
     };
 
     /**
      * Socket连接提示handler(Toast)
      */
     Handler toastMessageHandler = new Handler() {
         @Override
         public void handleMessage(Message msg) {
             super.handleMessage(msg);
             Bundle bundle = msg.getData();
             String message = bundle.getString(MessageUtil.MESSAGE);
             showToast(message, Toast.LENGTH_SHORT);
         }
     };
 
     /**
      * 等待框
      *
      * @param message 提示文字
      */
     private static void setDialogMessage(String message) {
         if (progressdialog == null) {
             progressdialog = new ProgressDialog(nowContext);
         }
         progressdialog.setTitle("学通宝收银");
         progressdialog.setMessage(message);
         progressdialog.setCancelable(false);
         progressdialog.show();
     }
 
     /**
      * 退出提示框
      *
      * @param message 提示文字
      */
     private void dialogExit(String message) {
         //初始化退出builder
         if (dialogExitBuilder == null) {
             dialogExitBuilder = new AlertDialog.Builder(nowContext);
         }
         dialogExitBuilder.setMessage(message);
         dialogExitBuilder.setTitle("提示");
         dialogExitBuilder.setIcon(R.mipmap.warning);
         dialogExitBuilder.setPositiveButton("确认", new DialogInterface.OnClickListener() {
             public void onClick(DialogInterface dialog, int which) {
                 dialog.dismiss();
                 //参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
                 System.exit(0);
             }
         });
         dialogExitBuilder.create().show();
     }
 
     /**
      * Toast消息提醒
      *
      * @param text     标题
      * @param duration 时长
      */
     public void showToast(String text, int duration) {
         //只创建一次
         if (toast == null) {
             toast = Toast.makeText(nowContext, text, duration);
         } else {
             toast.setText(text);
             toast.setDuration(duration);
         }
         toast.show();
     }
 
     public void startSocket() throws URISyntaxException {
         //初始化Socket配置
         IO.Options options = new IO.Options();
         options.transports = new String[]{"websocket"};
         options.reconnectionAttempts = maxReConnectionCount; // 设置一个重连的最大尝试次数，超过这个值后Socket.io会使用所有允许的其他连接方式尝试重连，直到最终失败。
         options.reconnectionDelay = 500;  //为Socket.io的重连设置一个时间间隔，内部会在多次重连尝试时采用该值的指数值间隔，用来避免性能损耗（500 > 1000 > 2000 > 4000 > 8000）
         options.reconnection = true;      //当连接终止后，是否允许Socket.io自动进行重连
         options.timeout = 9000;           //连接超时时间(ms)
         options.forceNew = true;
         options.query = "appid=cn.xuetongbao.xtbpay";
         socket = IO.socket("http://192.168.8.107:9096/", options);
         //连接成功
         socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 //重连机制
                 if (reConnectionCount > 0) {
                     //连接存储客户端信息
                     DeviceInfoInstance instance = DeviceInfoInstance.getSocketInstance();
                     HealthCheckRequest healthCheckRequest = new HealthCheckRequest();
                     healthCheckRequest.setEnCode(instance.getDeviceInfo().getEnCode());
                     socket.emit(SocketConstants.SocketEvent.HEALTH_CHECK, RequestUtil.createObject(healthCheckRequest), (Ack) args1 -> {
                         System.out.println("args1：" + args1.toString());
                     });
                 }
                 System.out.println("连接成功...");
                 toastMessageHandler.sendMessage(MessageUtil.createMessage("服务器连接成功"));
                 //关闭等待框
                 if (progressdialog != null) {
                     progressdialog.dismiss();
                 }
             }
         });
 
         //连接失败事件
         socket.on(Socket.EVENT_CONNECT_ERROR, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 System.out.println("Socket.EVENT_CONNECT_ERROR");
                 System.out.println("reConnectionCount：" + reConnectionCount);
                 if (reConnectionCount >= maxReConnectionCount) {
                     dialogExitHandler.sendMessage(MessageUtil.createMessage("服务器连接失败，请稍后再试"));
                 } else {
                     dialogMessageHandler.sendMessage(MessageUtil.createMessage("服务器连接失败，正在重新连接..."));
                 }
             }
         });
 
         //连接中事件
         socket.on(Socket.EVENT_RECONNECTING, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 reConnectionCount++;
                 System.out.println("Socket.EVENT_RECONNECTING");
                 dialogMessageHandler.sendMessage(MessageUtil.createMessage("正在连接服务器..."));
             }
         });
 
         //连接超时事件
         socket.on(Socket.EVENT_CONNECT_TIMEOUT, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 System.out.println("Socket.EVENT_CONNECT_TIMEOUT");
                 if (nowContext != null) {
                     dialogMessageHandler.sendMessage(MessageUtil.createMessage("与服务器连接超时，正在重新建立连接..."));
                     socket.connect();
                 }
             }
         });
 
         //心跳包
         socket.on(Socket.EVENT_PING, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 System.out.println("Socket.EVENT_PING");
             }
         });
         //心跳包
         socket.on(Socket.EVENT_PONG, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 System.out.println("Socket.EVENT_PONG");
             }
         });
 
         //消息接收事件
         socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 System.out.println("-----------接受到消息啦--------" + Arrays.toString(args));
             }
         });
 
         //连接断开事件
         socket.on(Socket.EVENT_DISCONNECT, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 reConnectionCount = 0;
                 System.out.println("客户端断开连接啦。。。");
                 if (nowContext != null) {
                     dialogMessageHandler.sendMessage(MessageUtil.createMessage("似乎与服务器断开连接,正在重新建立连接..."));
                     socket.connect();
                 }
             }
         });
 
         //交易事件
         socket.on(SocketConstants.SocketEvent.PAY, new Emitter.Listener() {
             @Override
             public void call(Object... args) {
                 Object data = args[0];
                 Object ackCallBack = args[1];
                 System.out.println("接收到服务端交易下单消息" + data);
                 CallPayRequest callPayRequest = JSON.parseObject(data.toString(), CallPayRequest.class);
                 if (callPayRequest != null) {
 
                 }
                 //data
                 CallPayResponse callPayResponse = new CallPayResponse();
                 callPayResponse.setResultCode(AppResultCode.Success.getCode());
                 callPayResponse.setResultMsg(AppResultCode.Success.getMsg());
 
                 //响应服务端
                 ((Ack) ackCallBack).call(JSON.toJSONString(callPayResponse));
             }
         });
         System.out.println("准备连接服务器...");
         socket.connect();
     }
 }

 注：仅供学习参考