【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();
    }
}

 

 注：僅供學習參考