springboot + jetty + websocket

jetty与tomcat

Jetty默认采用NIO结束在处理I/O请求上更占优势，在处理静态资源时，性能较高，Tomcat默认采

用BIO处理I/O请求，在处理静态资源时，性能较差。加之Tomcat + springboot-websocket会高并

发情况下会存在报[TEXT_XXX_WRITING]，使用同步发送 + 锁不能很好的解决此问题，所以采用

springboot + jetty方式

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <!-- <artifactId>spring-boot-starter</artifactId>-->
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- 排除Tomcat -->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- jetty -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>>4.9.3</version>
</dependency>

 开启服务扫描

@SpringBootApplication
// servlet扫描
@ServletComponentScan
public class ModelPlusApplication {

    public static void main(String[] args) {
        SpringApplication.run(ModelPlusApplication.class, args);
    }

}

websocket配置类

import org.eclipse.jetty.websocket.servlet.WebSocketServlet;
import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;
import javax.servlet.annotation.WebServlet;

// 路径
@WebServlet(urlPatterns = {"/websocket"})
public class ModelWebsocketServlet extends WebSocketServlet {

    @Override
    public void configure(WebSocketServletFactory webSocketServletFactory) {
        webSocketServletFactory.getPolicy().setIdleTimeout(60000);
        webSocketServletFactory.register(ModelWebsocket.class);
    }
}

webscoket代码

import com.alibaba.fastjson2.JSONObject;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;


@WebSocket
@Slf4j
public class ModelWebsocket {

    private final OkHttpClient okHttpClient = new OkHttpClient().newBuilder().build();
    Session session;

    @OnWebSocketConnect
    public void onConnect(Session session) throws IOException {
        this.session = session;
        String appId = null;
        try {
            appId = getRequestParameter(session,"appId");
            String url = "xxxxx";
            Request request = (new Request.Builder()).url(url).build();
            okhttp3.WebSocket webSocket = okHttpClient.newWebSocket(request, new ModelWebSocketListener());
            WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.put(webSocket, session);
            WebSocketSessionContext.SESSION_WEB_SOCKET_MAP.put(session, webSocket);
            log.info("[client and server] link open");
        } catch (ServiceException se) {
            log.error("[client and server] error open：[appId={}] {}", appId, se.getMessage());
            session.getRemote().sendString(JSONObject.toJSONString(Result.error(se.getCode(), se.getMessage())));
            closeConnection(session);
        } catch (Exception e) {
            log.error("[client and server] error open：[appId={}] {}", appId, e.toString());
            session.getRemote().sendString(JSONObject.toJSONString(Result.error(e.getMessage())));
            closeConnection(session);
        }
    }

    private String getRequestParameter(Session session, String key) {
        try {
            return session.getUpgradeRequest().getHeader(key);
        } catch (Exception e) {
            throw new ServiceException("请求的签名参数不可为空：" + key, HttpStatus.MISSING_PARAMETER);
        }
    }

    private void closeConnection(Session session) {
        if (session != null && session.isOpen()) {
            session.close();
        }
    }

    @OnWebSocketMessage
    public void onMessage(String message) throws IOException {
        log.info("[client to server]send message:{}", message);
        try {   
            WebSocketSessionContext.SESSION_WEB_SOCKET_MAP.get(session).send(message);
        } catch (ServiceException se) {
            log.error("[client and server] error send message：[message={}],{}", message, se.getMessage());
            session.getRemote().sendString(JSONObject.toJSONString(Result.error(se.getCode(), se.getMessage())));
            closeConnection(session);
        } catch (Exception e) {
            log.error("[client and server] error send message：[message={}],{}", message, e.getMessage());
            session.getRemote().sendString(JSONObject.toJSONString(Result.error(e.getMessage())));
            closeConnection(session);
        }
    }

    @OnWebSocketClose
    public void onClose(int statusCode, String reason) {
        log.info("[client and server] link close");
        okhttp3.WebSocket webSocket = WebSocketSessionContext.SESSION_WEB_SOCKET_MAP.get(session);
        WebSocketSessionContext.SESSION_WEB_SOCKET_MAP.remove(session);
        if (webSocket != null) {
            webSocket.close(statusCode, reason);
        }
    }

import com.alibaba.fastjson2.JSONObject;


import lombok.extern.slf4j.Slf4j;
import okhttp3.Response;
import okhttp3.WebSocket;
import okhttp3.WebSocketListener;
import okio.ByteString;
import org.eclipse.jetty.websocket.api.Session;

import java.io.IOException;

/**
 * @author chaochen25
 */
@Slf4j
public class ModelWebSocketListener extends WebSocketListener {

    public ModelWebSocketListener() {
    }

    StringBuilder sb = new StringBuilder();

    @Override
    public void onClosed(@org.jetbrains.annotations.NotNull WebSocket webSocket, int code, @org.jetbrains.annotations.NotNull String reason) {
        super.onClosed(webSocket, code, reason);
        log.warn("[server and engine]link closed, code is {} , reason is [{}]", code, reason);
    }

    @Override
    public void onClosing(@org.jetbrains.annotations.NotNull WebSocket webSocket, int code, @org.jetbrains.annotations.NotNull String reason) {
        super.onClosing(webSocket, code, reason);
        log.warn("[server and engine]link closing, code is {} , reason is [{}]", code, reason);
        Session session = WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.get(webSocket);
        WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.remove(webSocket);
        if (session != null && session.isOpen()) {
            session.close();
        }
    }

    @Override
    public void onFailure(@org.jetbrains.annotations.NotNull WebSocket webSocket, @org.jetbrains.annotations.NotNull Throwable t, Response response) {
        super.onFailure(webSocket, t, response);
        log.info("[server and engine]link failed，reason:{}", t.getMessage(), t);
        if (WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.get(webSocket) != null && WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.get(webSocket).isOpen()) {
            try {
                WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.get(webSocket).getRemote().sendString(JSONObject.toJSONString(new Result(-1, t.getMessage())));
            } catch (IOException e) {
                log.error("[server and engine]link failed，reason:{}", t.getMessage());
            }
        }
        webSocket.close(1001, t.getMessage());
        Session session = WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.get(webSocket);
        WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.remove(webSocket);
        if (session != null && session.isOpen()) {
            session.close();
        }
    }

    @Override
    public void onMessage(@org.jetbrains.annotations.NotNull WebSocket webSocket, @org.jetbrains.annotations.NotNull String text) {
        try {
            super.onMessage(webSocket, text);
    //        log.info("[server from engine]receive message:{}", text);
            WebSocketSessionContext.WEB_SOCKET_SESSION_MAP.get(webSocket).getRemote().sendString(text);
        } catch (IOException e) {
            log.error("[server and engine]link failed，reason:{}", e.getMessage());
        }
    }

    @Override
    public void onMessage(@org.jetbrains.annotations.NotNull WebSocket webSocket, @org.jetbrains.annotations.NotNull ByteString bytes) {
        super.onMessage(webSocket, bytes);
        log.info("[server from engine]receive message: {}", bytes);
    }

    @Override
    public void onOpen(@org.jetbrains.annotations.NotNull WebSocket webSocket, @org.jetbrains.annotations.NotNull Response response) {
        super.onOpen(webSocket, response);
        log.info("[server and engine]link open");
    }

}

import okhttp3.WebSocket;
import org.eclipse.jetty.websocket.api.Session;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class WebSocketSessionContext {

    public static final Map<WebSocket, Session> WEB_SOCKET_SESSION_MAP = new ConcurrentHashMap<>();

    public static final Map<Session, WebSocket> SESSION_WEB_SOCKET_MAP = new ConcurrentHashMap<>();

}