Springboot3.0 响应式WebSocket代码分享

已于 2022-12-31 22:50:05 修改
阅读量1.4k 收藏 6
点赞数
分类专栏： springboot3 reactive 文章标签： websocket java spring boot
于 2022-12-31 17:04:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chundonghan/article/details/128506156
版权

文章目录

工程目录结构

springboot3-reactive
  ┣ src/main/java
      ┣ com.es.springboot3
          ┣ cache
              ┣ WebSocketClientCache.java
          ┣ config
              ┣ ApplicationConfiguration.java
              ┣ RedissonAutoConfiguration.java
              ┣ WebConfiguration.java
              ┣ WebSocketConfiguration.java
          ┣ context
              ┣ SpringContextHolder.java
          ┣ entity
              ┣ websocket
                  ┣ WebSocketClient.java
                  ┣ WebSocketMessageRecord.java
          ┣ event
              ┣ MessageEvent.java
          ┣ handler
              ┣ BroadcastWebSocketHandler.java
              ┣ P2MPWebSocketHandler.java
              ┣ P2PWebSocketHandler.java
          ┣ listener
              ┣ MessageListener.java
          ┣ properties
              ┣ RedissonProperty.java
              ┣ RedissonSentinel.java
              ┣ RedissonSingle.java
          ┣ SpringBoot3ReactiveApplication.java
  ┣ src/main/resources
      ┣  application.yml
      ┣  logback-spring.xml
  ┣ pom.xml

代码及配置

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.es</groupId>
	<artifactId>springboot3-reactive</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<description>响应式</description>

	<properties>

		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.compiler.source>17</maven.compiler.source>
		<maven.compiler.target>17</maven.compiler.target>
		<spring-boot.version>3.0.0</spring-boot.version>
		<hutool.version>5.8.10</hutool.version>
		<fastjson.version>2.0.20</fastjson.version>
		<redisson.version>3.18.0</redisson.version>
	</properties>

	<dependencies>
	    <!--配置文件处理器-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>
		<!--Lombok-->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>jakarta.websocket</groupId>
			<artifactId>jakarta.websocket-api</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-webflux</artifactId>
		</dependency>
		<!-- hutool -->
		<dependency>
			<groupId>cn.hutool</groupId>
			<artifactId>hutool-all</artifactId>
		</dependency>
		<!--fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
		</dependency>

		<dependency>
			<groupId>org.redisson</groupId>
			<artifactId>redisson</artifactId>
		</dependency>
	</dependencies>


	<dependencyManagement>
		<dependencies>
			<!-- spring boot 依赖 -->
			<dependency>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-dependencies</artifactId>
				<version>${spring-boot.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
			<dependency>
				<groupId>cn.hutool</groupId>
				<artifactId>hutool-all</artifactId>
				<version>${hutool.version}</version>
			</dependency>
			<!--fastjson 版本-->
			<dependency>
				<groupId>com.alibaba</groupId>
				<artifactId>fastjson</artifactId>
				<version>${fastjson.version}</version>
			</dependency>
			<!-- redisson -->
			<dependency>
				<groupId>org.redisson</groupId>
				<artifactId>redisson</artifactId>
				<version>${redisson.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<finalName>${project.name}</finalName>
		<resources>
			<resource>
				<directory>src/main/resources</directory>
				<!--开启过滤，用指定的参数替换directory下的文件中的参数-->
				<filtering>true</filtering>
			</resource>
		</resources>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<encoding>utf-8</encoding>
					<source>17</source>
					<target>17</target>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<configuration>
					<archive>
						<manifest>
							<!-- 添加依赖jar路径 -->
							<addClasspath>true</addClasspath>
							<!-- 入口程序 -->
							<mainClass>com.es.springboot3.SpringBoot3ReactiveApplication</mainClass>
							<classpathPrefix>lib/</classpathPrefix>
						</manifest>
					</archive>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<executions>
					<execution>
						<id>copy</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>
								${project.build.directory}/lib
							</outputDirectory>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>

application.yml

server:
  port: 8009

application:
  name: @artifactId@
  version: @version@
spring:
  application:
    name: @artifactId@
  redisson:
    enabled: true
    server: single
    single:
      address: redis://192.168.31.167:6379
      connectionMinimumIdleSize: 5
      connectionPoolSize: 50
    password: 
    database: 14
    timeout: 3000

SpringBoot3ReactiveApplication.java

package com.es.springboot3;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBoot3ReactiveApplication {

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

}

WebSocketClientCache.java

package com.es.springboot3.cache;

import java.util.HashMap;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArraySet;

import org.redisson.api.RedissonClient;
import org.springframework.web.reactive.socket.WebSocketSession;

import com.es.springboot3.entity.websocket.WebSocketClient;

import lombok.experimental.UtilityClass;

@UtilityClass
public class WebSocketClientCache {
	
	private static final ConcurrentMap<String, HashMap<String, WebSocketClient>> WEB_SOCKET_CLIENT_MAP = new ConcurrentHashMap<>();

	public void setWebSocketClient(String source, WebSocketClient webSocketClient) {
		HashMap<String, WebSocketClient> webSocketClientCache = WEB_SOCKET_CLIENT_MAP.get(source);

		if (Objects.isNull(webSocketClientCache)) {
			webSocketClientCache = new HashMap<>();
		}
		WebSocketSession session = webSocketClient.getSession();
		if (Objects.nonNull(session)) {
			webSocketClientCache.put(session.getId(), webSocketClient);
			WEB_SOCKET_CLIENT_MAP.put(source, webSocketClientCache);
		}
		
	}
	
	public HashMap<String,WebSocketClient> getWebSocketClient(String source){
        return WEB_SOCKET_CLIENT_MAP.get(source);
    }
	
	
	public void delWebSocketClient(String source,String sessionId){
        WEB_SOCKET_CLIENT_MAP.get(source).remove(sessionId);
    }
}

ApplicationConfiguration.java

package com.es.springboot3.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration(proxyBeanMethods = false)
@EnableAsync
public class ApplicationConfiguration {
}

RedissonAutoConfiguration.java

package com.es.springboot3.config;


import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.es.springboot3.properties.RedissonProperty;
import com.es.springboot3.properties.RedissonSentinel;
import com.es.springboot3.properties.RedissonSingle;

import cn.hutool.core.util.StrUtil;
import lombok.RequiredArgsConstructor;

/**
 * redisson自动配置
 */
@RequiredArgsConstructor
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(RedissonProperty.class)
public class RedissonAutoConfiguration {
	
	private final RedissonProperty conf;
	
	@Bean(name = "redission", destroyMethod = "shutdown")
	public RedissonClient redission() {
		Config config = new Config();
		config.setCodec(new org.redisson.client.codec.StringCodec());
		if ("sentinel".equals(conf.getServer())) {
			RedissonSentinel sentinel = conf.getSentinel();
			config.useSentinelServers().setMasterName(sentinel.getMasterName())
					.addSentinelAddress(sentinel.getSentinelAddresses()).setPassword(conf.getPassword())
					.setDatabase(conf.getDatabase());
		} else {
			RedissonSingle single = conf.getSingle();
			SingleServerConfig serverConfig = config.useSingleServer().setAddress(single.getAddress())
					.setTimeout(conf.getTimeout()).setConnectionPoolSize(single.getConnectionPoolSize())
					.setConnectionMinimumIdleSize(single.getConnectionMinimumIdleSize())
					.setDatabase(conf.getDatabase());
			if (StrUtil.isNotBlank(conf.getPassword())) {
				serverConfig.setPassword(conf.getPassword());
			}
		}
		return Redisson.create(config);
	}
}

WebConfiguration.java

package com.es.springboot3.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.config.EnableWebFlux;

@Configuration(proxyBeanMethods = false)
@EnableWebFlux
public class WebConfiguration {

}

WebSocketConfiguration.java

package com.es.springboot3.config;

import java.util.HashMap;
import java.util.Map;

import org.redisson.api.RedissonClient;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.server.support.WebSocketHandlerAdapter;

import com.es.springboot3.handler.BroadcastWebSocketHandler;
import com.es.springboot3.handler.P2MPWebSocketHandler;
import com.es.springboot3.handler.P2PWebSocketHandler;

import lombok.RequiredArgsConstructor;
import reactor.core.publisher.Sinks;

@Configuration
@AutoConfigureAfter(RedissonAutoConfiguration.class)
@RequiredArgsConstructor
public class WebSocketConfiguration {
	
	private final RedissonClient redissonClient;
	
	@Bean
	public SimpleUrlHandlerMapping webSocketHandlerMapping() {
		Map<String,WebSocketHandler> webSocketHandlerMap = new HashMap<>();
		// 上线、单聊、群聊、聊天室发消息
		webSocketHandlerMap.put("/ws/p2p", new P2PWebSocketHandler(redissonClient));
		// 聊天室加入、退出
		webSocketHandlerMap.put("/ws/p2mp", new P2MPWebSocketHandler(redissonClient));
		// 广播
		webSocketHandlerMap.put("/ws/broadcast", new BroadcastWebSocketHandler(manySink()));
		
		return new SimpleUrlHandlerMapping(webSocketHandlerMap, Ordered.HIGHEST_PRECEDENCE);
	}
	
	@Bean
	public WebSocketHandlerAdapter webSocketHandlerAdapter() {
		return new WebSocketHandlerAdapter();
	}
	
	@Bean
	public Sinks.Many<String> manySink(){
		return Sinks.many().multicast().directBestEffort();
	}
	
}

SpringContextHolder.java

package com.es.springboot3.context;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

/**
 * Spring上下文工具类
 */
@Slf4j
@Service
@Lazy(false)
public class SpringContextHolder implements ApplicationContextAware, DisposableBean {

	private static ApplicationContext applicationContext = null;

	/**
	 * 取得存储在静态变量中的ApplicationContext.
	 */
	public static ApplicationContext getApplicationContext() {
		return applicationContext;
	}

	/**
	 * 实现ApplicationContextAware接口, 注入Context到静态变量中.
	 */
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) {
		SpringContextHolder.applicationContext = applicationContext;
	}

	/**
	 * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
	 */
	@SuppressWarnings("unchecked")
	public static <T> T getBean(String name) {
		return (T) applicationContext.getBean(name);
	}

	/**
	 * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
	 */
	public static <T> T getBean(Class<T> requiredType) {
		return applicationContext.getBean(requiredType);
	}

	/**
	 * 清除SpringContextHolder中的ApplicationContext为Null.
	 */
	public static void clearHolder() {
		if (log.isDebugEnabled()) {
			log.debug("清除SpringContextHolder中的ApplicationContext:" + applicationContext);
		}
		applicationContext = null;
	}

	/**
	 * 发布事件
	 * 
	 * @param event
	 */
	public static void publishEvent(ApplicationEvent event) {
		if (applicationContext == null) {
			return;
		}
		applicationContext.publishEvent(event);
	}

	/**
	 * 实现DisposableBean接口, 在Context关闭时清理静态变量.
	 */
	@Override
	@SneakyThrows
	public void destroy() {
		SpringContextHolder.clearHolder();
	}

	/**
	 * 环境变量中获取配置信息
	 * 
	 * @param key
	 * @return
	 */
	public static Object getProperty(String key) {
		return getApplicationContext().getEnvironment().getProperty(key);
	}

}

WebSocketClient.java

package com.es.springboot3.entity.websocket;

import java.io.Serializable;

import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;

import lombok.AllArgsConstructor;
import lombok.Data;
import reactor.core.publisher.FluxSink;

@Data
@AllArgsConstructor
public class WebSocketClient implements Serializable {
	/**
	* 
	*/
	private static final long serialVersionUID = 1L;

	private FluxSink<WebSocketMessage> sink;

	private WebSocketSession session;

	public void sendMsg(String msg) {
		sink.next(session.textMessage(msg));
	}

}

WebSocketMessageRecord.java

package com.es.springboot3.entity.websocket;

import java.time.LocalDateTime;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

/**
 * @param msg 消息内容
 * @param source 消息来源 消息发送者
 * @param target 消息目标 消息接收者
 * @param targetType 消息目标类型 SINGLE, GROUP, CHATROOM
 * @param createTime 消息创建时间
 */
public record WebSocketMessageRecord(String msg, String source, String target, String targetType, LocalDateTime createTime) {

	public static WebSocketMessageRecord trans(String message) {
		JSONObject msgJSON = JSON.parseObject(message);
		msgJSON.put("createTime", LocalDateTime.now());
		return JSON.toJavaObject(msgJSON, WebSocketMessageRecord.class);
	}
}

MessageEvent.java

package com.es.springboot3.event;

import org.springframework.context.ApplicationEvent;

public class MessageEvent extends ApplicationEvent{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public MessageEvent(Object source) {
		super(source);
	}

}

BroadcastWebSocketHandler.java

package com.es.springboot3.handler;

import java.time.Duration;
import java.util.concurrent.ConcurrentHashMap;

import org.springframework.stereotype.Component;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;

import com.es.springboot3.context.SpringContextHolder;
import com.es.springboot3.event.MessageEvent;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import reactor.core.publisher.Mono;
import reactor.core.publisher.Sinks;

@Slf4j
@Component
@RequiredArgsConstructor
public class BroadcastWebSocketHandler implements WebSocketHandler {

	public static ConcurrentHashMap<String, WebSocketSession> sessionBucket = new ConcurrentHashMap<>();

	private final Sinks.Many<String> manySink;
	

	@Override
	public Mono<Void> handle(WebSocketSession session) {
		sessionBucket.putIfAbsent(session.getId(), session);
		
		Mono<Void> receiveMono = session.receive().map(WebSocketMessage::getPayloadAsText)
				.doOnNext(data -> {
					MessageEvent messageEvent = new MessageEvent(data);
					SpringContextHolder.publishEvent(messageEvent);
					manySink.emitNext(data, Sinks.EmitFailureHandler.FAIL_FAST);
				}).then();

		Mono<Void> sendMono = session
				.send(Mono.delay(Duration.ofMillis(500)).thenMany(manySink.asFlux().map(msg -> session.textMessage(msg))))
				.then();

		return Mono.zip(receiveMono, sendMono).then();

	}

}

P2MPWebSocketHandler.java

package com.es.springboot3.handler;

import java.net.InetSocketAddress;
import java.util.Map;

import org.redisson.api.RSet;
import org.redisson.api.RedissonClient;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.socket.HandshakeInfo;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketSession;

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.http.HttpUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Slf4j
@Component
@RequiredArgsConstructor
public class P2MPWebSocketHandler implements WebSocketHandler {

	private final RedissonClient redissonClient;

	@Override
	public Mono<Void> handle(WebSocketSession session) {

		HandshakeInfo handshakeInfo = session.getHandshakeInfo();
		InetSocketAddress remoteAddress = handshakeInfo.getRemoteAddress();
		HttpHeaders headers = handshakeInfo.getHeaders();
		String query = handshakeInfo.getUri().getQuery();
		Map<String, String> paramMap = HttpUtil.decodeParamMap(query, CharsetUtil.CHARSET_UTF_8);

		String userId = paramMap.get("userId");
		String roomId = paramMap.get("roomId"); // 聊天室

		Mono<Void> receiveMono = session.receive().doOnSubscribe(conn -> {
			log.info("建立连接：{}，用户ip：{}，房间id：{}，用户：{}", session.getId(), remoteAddress.getHostName(), roomId, userId);
		}).doOnComplete(() -> {
			exitFromChatroom(roomId, userId);
			log.info("doOnComplete关闭连接：{}", session.getId());
		}).doOnCancel(() -> {
			exitFromChatroom(roomId, userId);
			log.info("doOnCancel关闭连接：{}", session.getId());
		}).then();

		Mono<Void> sendMono = session.send(Flux.create(sink -> entryToChatroom(roomId, userId)));

		return Mono.zip(receiveMono, sendMono).then();

	}

	void entryToChatroom(String roomId, String userId) {
		RSet<String> ids = redissonClient.getSet("chatroom:"+roomId);
		ids.add(userId);
	}

	void exitFromChatroom(String roomId, String userId) {
		RSet<String> ids = redissonClient.getSet("chatroom:"+roomId);
		ids.remove(userId);
	}

}

P2PWebSocketHandler.java

package com.es.springboot3.handler;

import java.net.InetSocketAddress;
import java.util.Map;

import org.redisson.api.RedissonClient;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.socket.HandshakeInfo;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketSession;

import com.es.springboot3.cache.WebSocketClientCache;
import com.es.springboot3.context.SpringContextHolder;
import com.es.springboot3.entity.websocket.WebSocketClient;
import com.es.springboot3.entity.websocket.WebSocketMessageRecord;
import com.es.springboot3.event.MessageEvent;

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.http.HttpUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Slf4j
@Component
@RequiredArgsConstructor
public class P2PWebSocketHandler implements WebSocketHandler {


	private final RedissonClient redissonClient;

	@Override
	public Mono<Void> handle(WebSocketSession session) {

		HandshakeInfo handshakeInfo = session.getHandshakeInfo();
		InetSocketAddress remoteAddress = handshakeInfo.getRemoteAddress();
		HttpHeaders headers = handshakeInfo.getHeaders();
		String query = handshakeInfo.getUri().getQuery();
		Map<String, String> paramMap = HttpUtil.decodeParamMap(query, CharsetUtil.CHARSET_UTF_8);

		String userId = paramMap.get("userId");

		Mono<Void> receiveMono = session.receive().doOnSubscribe(conn -> {
			log.info("建立连接：{}，用户ip：{}，用户：{}", session.getId(), remoteAddress.getHostName(), userId);
		}).doOnNext(msg -> {
			String data = msg.getPayloadAsText();
			WebSocketMessageRecord messageRecord = WebSocketMessageRecord.trans(data);
			sendP2P(messageRecord);
		}).doOnComplete(() -> {
			WebSocketClientCache.delWebSocketClient(userId, session.getId());
			log.info("doOnComplete关闭连接：{},{}", userId, session.getId());
		}).doOnCancel(() -> {
			WebSocketClientCache.delWebSocketClient(userId, session.getId());
			log.info("doOnCancel关闭连接：{},{}", userId, session.getId());
		}).then();

		Mono<Void> sendMono = session
				.send(Flux.create(sink -> handleClient(userId, new WebSocketClient(sink, session))));

		return Mono.zip(receiveMono, sendMono).then();

	}

	void handleClient(String source, WebSocketClient webSocketClient) {
		WebSocketClientCache.setWebSocketClient(source, webSocketClient);
	}

	void sendP2P(WebSocketMessageRecord messageRecord) {
		MessageEvent messageEvent = new MessageEvent(messageRecord);
		SpringContextHolder.publishEvent(messageEvent);

	}
}

MessageListener.java

package com.es.springboot3.listener;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Objects;

import org.redisson.api.RReliableTopic;
import org.redisson.api.RSet;
import org.redisson.api.RedissonClient;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.es.springboot3.cache.WebSocketClientCache;
import com.es.springboot3.entity.websocket.WebSocketClient;
import com.es.springboot3.entity.websocket.WebSocketMessageRecord;
import com.es.springboot3.event.MessageEvent;

import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Component
@RequiredArgsConstructor
public class MessageListener {

	private final RedissonClient redissonClient;
	
	@PostConstruct
	public void messageTopicListen() {

		RReliableTopic messageTopic = redissonClient.getReliableTopic("messageTopic");

		messageTopic.addListener(String.class, (channel, messageRecordObj) -> {
			log.info("channel:{}", channel);
			log.info("msg:{}", messageRecordObj);
			
			WebSocketMessageRecord messageRecord = JSON.toJavaObject(JSON.parseObject(messageRecordObj), WebSocketMessageRecord.class);

			String msg = JSON.toJSONString(messageRecord);
			String source = messageRecord.source();
			String target = messageRecord.target();

			String targetType = messageRecord.targetType();
			switch (targetType) {
			case "SINGLE":
				HashMap<String, WebSocketClient> sourceWebSocketClientMap = WebSocketClientCache.getWebSocketClient(source);

				if (Objects.nonNull(sourceWebSocketClientMap)) {
					sourceWebSocketClientMap.forEach((k, sourceWebSocketClient) -> {
						sourceWebSocketClient.sendMsg(msg);
					});
				}

				HashMap<String, WebSocketClient> targetWebSocketClientMap = WebSocketClientCache.getWebSocketClient(target);
				if (Objects.nonNull(targetWebSocketClientMap)) {
					targetWebSocketClientMap.forEach((k, targetWebSocketClient) -> {
						targetWebSocketClient.sendMsg(msg);
					});
				}
				break;
			case "GROUP":
				// 根据target 获取组成员
				List<String> members = Arrays.asList("1", "2", "3");

				members.parallelStream().forEach((id) -> {
					HashMap<String, WebSocketClient> webSocketClientMap = WebSocketClientCache.getWebSocketClient(id);
					if (Objects.nonNull(webSocketClientMap)) {
						webSocketClientMap.forEach((k, webSocketClient) -> {
							webSocketClient.sendMsg(msg);
						});
					}
				});

				break;
			case "CHATROOM":

				RSet<String> ids = redissonClient.getSet("chatroom:" + target);
				ids.parallelStream().forEach((id) -> {
					HashMap<String, WebSocketClient> webSocketClientMap = WebSocketClientCache.getWebSocketClient(id);
					if (Objects.nonNull(webSocketClientMap)) {
						webSocketClientMap.forEach((k, webSocketClient) -> {
							webSocketClient.sendMsg(msg);
						});
					}
				});

				break;
			}
		});
	}

	@Async
	@EventListener
	public void messageListen(MessageEvent messageEvent) {
		log.info("{}", JSON.toJSONString(messageEvent.getSource()));
		WebSocketMessageRecord messageRecord = (WebSocketMessageRecord) messageEvent.getSource();
		RReliableTopic messageTopic = redissonClient.getReliableTopic("messageTopic");
		messageTopic.publish(JSON.toJSONString(messageRecord));
		
	}
}

RedissonProperty.java

package com.es.springboot3.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;

import lombok.Data;

@Data
@ConfigurationProperties(prefix = "spring.redisson")
public class RedissonProperty {

	private boolean enabled;

	/**
	 * 服务类型 single sentinel cluster
	 */
	private String server;

	/**
	 * 单点配置
	 */
	private RedissonSingle single;

	/**
	 * 哨兵配置
	 */
	private RedissonSentinel sentinel;

	/**
	 * 密码
	 */
	private String password;

	/**
	 * 设置的数据库0-15
	 */
	private int database;

	/**
	 * 超时时间
	 */
	private int timeout;

}

RedissonSentinel.java

package com.es.springboot3.properties;

import lombok.Data;

@Data
public class RedissonSentinel {

	/*
	 * 以下参数暂未设置
	 */
	private int slaveConnectionPoolSize;

	private int masterConnectionPoolSize;

	private String[] sentinelAddresses;

	private String masterName;
}

RedissonSingle.java

package com.es.springboot3.properties;

import lombok.Data;

@Data
public class RedissonSingle {

	/**
	 * 链接地址
	 */
	private String address;

	/**
	 * 连接最小闲置进程数
	 */
	private int connectionMinimumIdleSize;
	/**
	 * 连接池大小
	 */
	private int connectionPoolSize;
}

客户端连接

postman

在这里插入图片描述

创建连接

在这里插入图片描述

发送消息

在这里插入图片描述

接收消息

在这里插入图片描述

chundonghan
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
如何使用Spring Boot 3.X + WebSocket来实现推送消息功能
专注于深入研究多种编程语言，以实战为导向，逐步拓展开发技能，提升工程化编码和思维能力，展现无敌技术实力。
06-16 1169
使用Spring Boot 3.X + WebSocket实现推送消息功能非常简单。通过添加依赖、创建WebSocket处理程序、配置和前端交互，可以实现实时消息的推送和接收，提升应用的实时性和用户体验。
jakarta.websocket-api-1.1.2-API文档-中英对照版.zip
05-04
赠送jar包：jakarta.websocket-api-1.1.2.jar； 赠送原API文档：jakarta.websocket-api-1.1.2-javadoc.jar； 赠送源代码：jakarta.websocket-api-1.1.2-sources.jar； 赠送Maven依赖信息文件：jakarta.websocket-api-1.1.2.pom； 包含翻译后的API文档：jakarta.websocket-api-1.1.2-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：jakarta.websocket:jakarta.websocket-api:1.1.2； 标签：websocket、api、jakarta、jar包、java、中英对照文档； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。 双语对照，边学技术、边学英语。
Spring boot3简单实现websocket（拦截器，跨域，服务端发送）
lingxiaoNo1的博客
04-11 3239
/
Spring Boot + WebSocket 实时监控，实战来了！
最新发布
emprere的博客
06-11 137
因公众号更改推送规则，请点“在看”并加“星标”第一时间获取精彩技术分享点击关注#互联网架构师公众号，领取架构师全套资料 都在这里0、2T架构师学习资料干货分上一篇：2T架构师学习资料干货分享大家好，我是互联网架构师！写在前面此异常非彼异常，标题所说的异常是业务上的异常。最近做了一个需求，消防的设备巡检，如果巡检发现异常，通过手机端提交，后台的实时监控页面实时获取到该设备的信息及位置，然后安排员...
Springboot整合WebScoket
lu__lala的博客
09-02 1458
WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。websocket 协议是在 http 协议上的一种补充协议，是 html5 的新特性，是一种持久化的协议。
Springboot3.X集成WebSocket完整流程
qq_43437208的博客
03-12 2798
pom文件。--spring 版本--> < parent > < groupId > org.springframework.boot < artifactId > spring-boot-starter-parent < version > 3.0.5
springboot + jwt + websocket + 拦截
09-02
在IT行业中，Spring Boot、JWT（JSON Web Token）和WebSocket是三个非常重要的技术概念，而“拦截”通常指的是在系统中实现的一种中间件机制，用于处理请求或响应。结合提供的标题和描述，我们可以深入探讨这四个...
springboot+vue实现websocket配置过程解析
08-19
描述: 本文主要介绍了 SpringBoot+Vue 实现 WebSocket 配置过程解析，通过示例代码进行详细的介绍，对大家的学习或者工作具有一定的参考学习价值。 标签: SpringBoot Vue WebSocket 知识点： 1. 引入依赖：在 ...
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
在这个项目"springboot-rabbitMQ-websocket"中，我们将探讨如何将这三个技术整合起来，实现高效的数据发布和实时接收。 首先，Spring Boot整合RabbitMQ主要涉及以下几个步骤： 1. **添加依赖**：在项目中，我们...
基于SpringBoot与Netty的WebSocket弹幕系统设计源码
04-14
后端使用SpringBoot 2.4.3进行开发，利用Netty实现WebSocket通信，同时结合Redis进行数据存储和处理。前端采用Vue框架，通过WebSocket与后端进行实时数据通信。系统还采用DFA算法模型对敏感词进行过滤，确保内容的...
springboot+netty+websocket+redis
03-08
**SpringBoot+Netty+WebSocket+Redis：构建分布式实时聊天应用** 在当今的互联网世界中，实时通信和数据共享是许多应用程序的核心需求。Spring Boot作为一款流行的Java框架，因其简洁的配置和快速开发特性而备受...
如何使用Spring Boot 3.X + WebSocket来实现推送消息功能，并可动态开启、关闭和取消定时任务（加强版）
专注于深入研究多种编程语言，以实战为导向，逐步拓展开发技能，提升工程化编码和思维能力，展现无敌技术实力。
06-18 849
通过Spring Boot 3.X与WebSocket可以实现消息推送功能，需要创建WebSocket配置类并处理连接和消息的逻辑。为了动态地启用、关闭和取消定时任务，使用Spring的任务调度功能，并创建一个管理器类来管理任务。这样，可以轻松地实现消息推送和灵活的定时任务管理。
如何利用Spring Boot 3.X与WebSocket实现消息推送功能，以及如何动态地启用、关闭和取消定时任务？
专注于深入研究多种编程语言，以实战为导向，逐步拓展开发技能，提升工程化编码和思维能力，展现无敌技术实力。
06-18 1107
通过Spring Boot 3.X与WebSocket可以实现消息推送功能，需要创建WebSocket配置类并处理连接和消息的逻辑。为了动态地启用、关闭和取消定时任务，使用Spring的任务调度功能，并创建一个管理器类来管理任务。这样，可以轻松地实现消息推送和灵活的定时任务管理。
Spring Boot 3 + Vue 3 整合 WebSocket (STOMP协议) 实现广播和点对点实时消息
有来技术
12-14 3026
文章深入介绍了Spring Boot 3整合WebSocket及Vue 3构建实时通信应用，使用STOMP协议实现连接、广播和点对点推送。提供详细代码示例，帮助读者掌握Spring Boot中WebSocket的应用。
【Spring实战项目】SpringBoot3整合WebSocket+拦截器实现登录验证！从原理到实战
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
04-03 2391
WebSocket是基于TCP协议的一种网络协议，它实现了浏览器与服务器全双工通信，支持客户端和服务端之间相互发送信息。在有WebSocket之前，如果服务端数据发生了改变，客户端想知道的话，只能采用定时轮询的方式去服务端获取，这种方式很大程度上增大了服务器端的压力，有了WebSocket之后，如果服务端数据发生改变，可以立即通知客户端，客户端就不用轮询去换取，降低了服务器的压力。目前主流的浏览器都已经支持WebSocket协议了。
WebSocket实现聊天室功能(springboot+vue3+vite)
qq_49721447的博客
09-03 2822
WebSocket实现聊天室功能(springboot+vue3+vite)
Spring Boot 3使用Spring WebFlux + WebSocket(简单实现)
lingxiaoNo1的博客
04-11 2173
一部分答案是需要一个非阻塞的网络堆栈来处理少量线程的并发，并使用更少的硬件资源进行扩展。远离Servlet非阻塞I/O和Servlet API 的其余部分，因为他们的通信是同步的(Filter, Servlet) 或阻塞的 (getParameter, getPart)。Spring WebFlux是一个新的通用 API 作为跨任何非阻塞运行时的基础的动机。这很重要，因为服务器（例如 Netty）在异步、非阻塞中得到了很好的实践。答案的另一部分是函数式编程。
SpringBoot从入门到精通系列三：WebSocket
zhengzaifeidelushang的博客
09-30 637
SpringBoot从入门到精通系列三：WebSocket使用@ServerEndpoint开发WebSocket1.定义pom.xml2.定义WebSocket处理类3.配置ServerEndpointExporter Bean3.使用JavaScript来开发WebSocket客户端4.主程序类 使用WebSocket能让客户端与服务端进行双向的实时通信。当客户端与服务端之间交互的内容较多或对实时性要求较高时，可使用WebSocket。 使用@ServerEndpoint开发WebSocket Spri
SpringBoot+WebSocket实现服务端、客户端
z_ssyy的博客
06-26 8399
百度百科介绍：WebSokcet在公司实际使用websocket开发，一般来都是这样的架构，首先websocket服务端是一个单独的项目，其他需要通讯的项目都是以客户端来连接，由服务端控制消息的发送方式(群发、指定发送)。但是也会有服务端、客户端在同一个项目当中，具体看项目怎么使用。本文呢，采用的是服务端与客户端分离来实现，包括使用springboot搭建websokcet服务端、html5客户端、springboot后台客户端， 具体看下面代码。
springboot3.0 怎么配置websocket
07-24
在Spring Boot 3.0中配置WebSocket，你可以按照以下步骤进行操作： 1. 添加依赖：在`pom.xml`文件中添加WebSocket依赖，例如： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值