springboot设置sessions时间

可以在application.properties文件中设置session的超时时间，例如：

server.servlet.session.timeout=30m

这将设置session的超时时间为30分钟。

相关问题

springboot与uni前端建立长链接实现的源码

建立长连接的实现方式一般有两种：WebSocket和SSE(Server-Sent Events)。下面分别介绍它们在Spring Boot框架下的实现方法。

## WebSocket

### 1.创建WebSocket Endpoint

首先，我们需要创建一个WebSocket Endpoint，这个Endpoint将处理客户端与服务器之间的WebSocket通信。创建方法如下：

import org.springframework.stereotype.Component;
import org.springframework.web.socket.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

@Component
public class WebSocketServer implements WebSocketHandler {

    //存储所有的socket连接
    private static final List<WebSocketSession> sessions = new CopyOnWriteArrayList<>();

    //连接成功建立后，向所有客户端发送消息
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        sessions.add(session);
        System.out.println("连接成功建立！");
    }

    //接收到客户端消息后，向所有客户端广播消息
    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        System.out.println("接收到客户端消息：" + message.getPayload());
        broadcast(message.getPayload().toString());
    }

    //连接关闭后，从列表中删除对应的socket连接
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
        sessions.remove(session);
        System.out.println("连接已关闭：" + closeStatus.getReason());
    }

    //广播消息给所有客户端
    private void broadcast(String message) {
        TextMessage textMessage = new TextMessage(message);
        for (WebSocketSession session : sessions) {
            try {
                session.sendMessage(textMessage);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

### 2.配置WebSocket

在Spring Boot中，我们需要添加WebSocket的依赖：

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

然后，在配置类中添加WebSocket配置：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

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

    public WebSocketServer webSocketServer() {
        return new WebSocketServer();
    }
}

这里我们将WebSocket Endpoint注册到了`/websocket`路径下，并且设置了跨域访问。

### 3.前端页面实现

在前端页面中，使用`WebSocket`对象与服务器建立连接，并发送消息与接收消息。例如：

var websocket = new WebSocket("ws://localhost:8080/websocket");

websocket.onopen = function() {
    console.log("连接已建立！");
}

websocket.onmessage = function(event) {
    console.log("接收到服务器消息：" + event.data);
}

websocket.onclose = function(event) {
    console.log("连接已关闭：" + event.reason);
}

function send() {
    var message = document.getElementById("message").value;
    websocket.send(message);
}

## SSE

### 1.创建Controller

首先，我们需要创建一个Controller，这个Controller将负责发送SSE（Server-Sent Events）数据流给客户端。创建方法如下：

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

@RestController
public class SSEController {

    //每隔1秒向客户端发送一条消息
    @GetMapping(value = "/sse", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> sse() {
        return Flux.interval(Duration.ofSeconds(1)).map(i -> "当前时间：" + new Date());
    }
}

这里使用了Reactor框架的`Flux`类，每隔1秒向客户端发送一条消息。

### 2.前端页面实现

在前端页面中，使用`EventSource`对象与服务器建立连接，并接收服务器发送的SSE数据流。例如：

var eventSource = new EventSource("http://localhost:8080/sse");

eventSource.onmessage = function(event) {
    console.log("接收到服务器消息：" + event.data);
}

eventSource.onerror = function(event) {
    console.log("连接已断开！");
}

注意，这里使用的是`EventSource`对象，而不是`WebSocket`对象。

## 总结

无论是WebSocket还是SSE，都可以实现客户端与服务器之间的长连接。WebSocket适用于实时互动的场景，例如聊天室、直播间等；而SSE适用于需要定时向客户端发送数据的场景，例如股票行情、天气预报等。在Spring Boot框架下，实现WebSocket和SSE都非常简单，只需要写几行代码即可。

springboot整合websocket，websocket的拦截器和消息处理器及websocket实现类怎么写

以下是在Spring Boot项目中整合WebSocket的步骤，包括拦截器、消息处理器和WebSocket实现类的编写：

1. 添加依赖

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

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

2. 编写WebSocket配置类

创建一个WebSocketConfig类，用于配置WebSocket相关的内容，包括注册WebSocket处理器、拦截器等。

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Autowired
    private MyWebSocketHandler myWebSocketHandler;

    @Autowired
    private MyHandshakeInterceptor myHandshakeInterceptor;

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myWebSocketHandler, "/websocket")
                .addInterceptors(myHandshakeInterceptor);
    }
}

在这个配置类中，我们注册了一个WebSocket处理器和一个握手拦截器。WebSocket处理器用于处理WebSocket连接和消息，握手拦截器用于拦截WebSocket连接请求并进行一些处理。

3. 编写WebSocket处理器

创建一个WebSocket处理器类，用于处理WebSocket连接和消息。

@Component
public class MyWebSocketHandler extends TextWebSocketHandler {

    private static final Logger logger = LoggerFactory.getLogger(MyWebSocketHandler.class);

    private static final Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>();

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        logger.info("WebSocket连接建立成功：{}", session.getId());
        sessions.put(session.getId(), session);
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        logger.info("收到消息：{}", message.getPayload());
        // 处理消息
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        logger.info("WebSocket连接关闭：{}，状态：{}", session.getId(), status);
        sessions.remove(session.getId());
    }

    public static void sendMessage(String sessionId, String message) throws IOException {
        WebSocketSession session = sessions.get(sessionId);
        if (session != null && session.isOpen()) {
            session.sendMessage(new TextMessage(message));
        }
    }
}

在这个处理器类中，我们重写了WebSocket处理器的三个方法：afterConnectionEstablished、handleTextMessage和afterConnectionClosed。afterConnectionEstablished方法在WebSocket连接建立成功后被调用，handleTextMessage方法用于处理收到的消息，afterConnectionClosed方法在WebSocket连接关闭后被调用。

4. 编写握手拦截器

创建一个握手拦截器类，用于拦截WebSocket连接请求并进行一些处理。

@Component
public class MyHandshakeInterceptor implements HandshakeInterceptor {

    private static final Logger logger = LoggerFactory.getLogger(MyHandshakeInterceptor.class);

    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
        logger.info("WebSocket握手拦截器：beforeHandshake");
        // 进行一些处理
        return true;
    }

    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
        logger.info("WebSocket握手拦截器：afterHandshake");
    }
}

在这个握手拦截器类中，我们重写了握手拦截器的两个方法：beforeHandshake和afterHandshake。beforeHandshake方法在WebSocket连接请求到达服务器端时被调用，afterHandshake方法在WebSocket连接握手成功后被调用。

5. 编写WebSocket实现类

创建一个WebSocket实现类，用于实现WebSocket的具体业务逻辑。

@Controller
public class MyWebSocketController {

    @MessageMapping("/hello")
    @SendTo("/topic/greetings")
    public String greeting(String message) throws Exception {
        Thread.sleep(1000); // 模拟处理时间
        return "Hello, " + message + "!";
    }
}

在这个WebSocket实现类中，我们使用了@MessageMapping注解来指定处理消息的路径，使用@SendTo注解来指定返回消息的路径。

6. 测试WebSocket连接

在客户端中，可以使用JavaScript代码来测试WebSocket连接：

var socket = new WebSocket("ws://localhost:8080/websocket");

socket.onopen = function(event) {
    console.log("WebSocket连接已建立");
    socket.send("Hello, WebSocket!");
};

socket.onmessage = function(event) {
    console.log("收到消息：" + event.data);
};

socket.onclose = function(event) {
    console.log("WebSocket连接已关闭");
};

以上就是在Spring Boot项目中整合WebSocket的步骤，包括拦截器、消息处理器和WebSocket实现类的编写。