springboot集成ws

框架如何实现双向通信？

SpringBoot集成WebSocket框架可以通过使用Spring的WebSocket模块来实现双向通信。具体来说，需要定义一个继承自TextWebSocketHandler或BinaryWebSocketHandler的WebSocket处理器，并在配置类中使用@EnableWebSocket注解启用WebSocket。在客户端和服务端建立连接后，可以通过该处理器来处理收到的数据，并向客户端发送响应消息，实现双向通信。

相关问题

springboot集成websocket

在Spring Boot中集成WebSocket需要进行以下步骤：

1. 添加依赖

在 `pom.xml` 文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

2. 配置WebSocket

在Spring Boot中，我们可以通过`@Configuration`注解来配置WebSocket。在配置类中，我们需要实现`WebSocketConfigurer`接口，并重写`registerWebSocketHandlers()`方法。

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/ws").setAllowedOrigins("*");
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new MyHandler();
    }
}

在上述代码中，我们注册了一个名为`/ws`的WebSocket处理程序，并设置了允许的来源。

3. 实现WebSocket处理程序

我们需要实现`WebSocketHandler`接口来处理WebSocket连接的各种事件，例如打开、关闭、接收消息等。以下是一个简单的WebSocket处理程序的示例：

public class MyHandler implements WebSocketHandler {

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // 连接建立时的处理逻辑
    }

    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        // 处理接收到的消息
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        // 处理传输错误
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
        // 连接关闭时的处理逻辑
    }

    @Override
    public boolean supportsPartialMessages() {
        return false;
    }
}

在上面的代码中，我们实现了`WebSocketHandler`接口，并重写了几个方法来处理WebSocket连接的各种事件。

4. 发送和接收消息

在处理程序中，我们可以使用`WebSocketSession`对象来发送和接收消息。以下是一个简单的示例：

public class MyHandler implements WebSocketHandler {

    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        String payload = message.getPayload().toString();
        session.sendMessage(new TextMessage("Hello, " + payload + "!"));
    }
}

在上面的代码中，我们从接收到的消息中获取了内容，并发送了一个带有“Hello”前缀的响应。

以上就是在Spring Boot中集成WebSocket的基本步骤。

springboot 集成ServerSocket

Spring Boot 集成 ServerSocket 可以通过以下步骤实现：

1. 在 pom.xml 文件中添加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

2. 创建一个 ServerSocketService 类，用于处理 Socket 连接请求和消息处理：

@Service
public class ServerSocketService {

    private ServerSocket serverSocket;

    @Autowired
    private MyWebSocketHandler myWebSocketHandler;

    @PostConstruct
    public void init() {
        try {
            serverSocket = new ServerSocket(8080);
            while (true) {
                Socket socket = serverSocket.accept();
                InputStream inputStream = socket.getInputStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
                String line = reader.readLine();
                myWebSocketHandler.sendMessage(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 创建一个 MyWebSocketHandler 类，用于处理 Socket 连接后的消息：

@Component
public class MyWebSocketHandler {

    private List<WebSocketSession> sessions = new CopyOnWriteArrayList<>();

    public void sendMessage(String message) {
        for (WebSocketSession session : sessions) {
            try {
                session.sendMessage(new TextMessage(message));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @OnOpen
    public void onOpen(WebSocketSession session) {
        sessions.add(session);
    }

    @OnMessage
    public void onMessage(WebSocketSession session, String message) {
        sendMessage(message);
    }

    @OnClose
    public void onClose(WebSocketSession session) {
        sessions.remove(session);
    }

    @OnError
    public void onError(Throwable throwable) {
        throwable.printStackTrace();
    }
}

4. 在 Spring Boot 主类中添加 @EnableWebSocket 注解：

@SpringBootApplication
@EnableWebSocket
public class Application {

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

5. 配置 WebSocket 的处理器和拦截器：

@Configuration
public class WebSocketConfig implements WebSocketConfigurer {

    @Autowired
    private MyWebSocketHandler myWebSocketHandler;

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myWebSocketHandler, "/ws").addInterceptors(new WebSocketInterceptor());
    }
}

6. 创建一个 WebSocketInterceptor 类，用于处理 WebSocket 连接的拦截逻辑：

public class WebSocketInterceptor implements HandshakeInterceptor {

    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
        return true;
    }

    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
    }
}

这样，Spring Boot 就可以集成 ServerSocket 了。当有新的 Socket 连接到服务器时，会调用 ServerSocketService 中的 init() 方法，该方法会一直等待 Socket 消息的到来，一旦有消息到来，就会将消息发送到 MyWebSocketHandler 中，MyWebSocketHandler 会将消息发送给所有已连接的 WebSocket 客户端。