java使用springboot完成点对点连接的代码
时间: 2023-03-15 13:52:40 浏览: 73
可以使用SpringBoot的WebSocket模块来实现点对点连接。这里有一个示例代码:https://github.com/codepediaorg/spring-boot-websocket-example
相关问题
springboot怎么使用websocket来完成点对点聊天
使用 Spring Boot 来实现 WebSocket 的点对点聊天可以分为以下几个步骤:
1. 添加依赖
在 pom.xml 文件中添加以下依赖:
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
```
2. 创建 WebSocket 配置类
创建一个 WebSocket 配置类,配置并启用 WebSocket:
```java
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(new ChatWebSocketHandler(), "/chat").setAllowedOrigins("*");
}
}
```
上面的代码中,我们创建了一个 `WebSocketConfig` 类,实现了 `WebSocketConfigurer` 接口的 `registerWebSocketHandlers` 方法。在该方法中,我们创建了一个 `ChatWebSocketHandler` 处理器,并将其映射到 `/chat` 路径上。
3. 创建 WebSocket 处理器
创建一个 WebSocket 处理器,处理 WebSocket 的连接、消息和关闭等操作:
```java
public class ChatWebSocketHandler extends TextWebSocketHandler {
private static final Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>();
@Override
public void afterConnectionEstablished(WebSocketSession session) throws Exception {
sessions.put(session.getId(), session);
}
@Override
protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
for (WebSocketSession s : sessions.values()) {
if (s.isOpen() && !s.getId().equals(session.getId())) {
s.sendMessage(message);
}
}
}
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
sessions.remove(session.getId());
}
}
```
上面的代码中,我们创建了一个 `ChatWebSocketHandler` 类,继承了 `TextWebSocketHandler` 类。在该处理器中,我们使用了一个 `ConcurrentHashMap` 来保存所有 WebSocket 连接的会话。当有新的 WebSocket 连接时,我们将其会话保存到 `sessions` 中。当有消息发送时,我们遍历 `sessions` 中的所有会话,并将消息发送给其他的会话。当有 WebSocket 连接关闭时,我们从 `sessions` 中移除该会话。
4. 创建控制器
创建一个控制器,处理页面请求和 WebSocket 连接:
```java
@Controller
public class ChatController {
@RequestMapping("/chat")
public String chat() {
return "chat";
}
}
```
上面的代码中,我们创建了一个 `ChatController` 类,使用 `@RequestMapping` 注解来映射页面请求,并返回 `chat` 字符串,表示返回 `chat.html` 页面。在该页面中,我们可以使用 JavaScript 来连接 WebSocket。
5. 创建页面
创建一个 HTML 页面,包含 JavaScript 代码,使用 WebSocket 连接到服务器:
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>WebSocket Chat</title>
</head>
<body>
<textarea id="chat-window" style="width: 100%; height: 300px;"></textarea>
<input type="text" id="chat-message" style="width: 100%;">
<button id="chat-send">Send</button>
<script>
var ws = new WebSocket('ws://' + window.location.hostname + ':8080/chat');
ws.onopen = function() {
console.log('WebSocket opened');
};
ws.onmessage = function(event) {
var message = event.data;
var chatWindow = document.getElementById('chat-window');
chatWindow.innerHTML += message + '\n';
chatWindow.scrollTop = chatWindow.scrollHeight;
};
ws.onclose = function() {
console.log('WebSocket closed');
};
var chatMessage = document.getElementById('chat-message');
var chatSend = document.getElementById('chat-send');
chatSend.onclick = function() {
var message = chatMessage.value;
ws.send(message);
chatMessage.value = '';
};
</script>
</body>
</html>
```
上面的代码中,我们创建了一个 HTML 页面,使用 JavaScript 来连接 WebSocket,并在页面中显示聊天记录和发送消息。
6. 运行应用程序
在终端中进入项目目录,执行以下命令运行应用程序:
```
mvn spring-boot:run
```
现在你可以在浏览器中打开 `http://localhost:8080/chat` 地址,开始点对点聊天了。
springboot 2.5.4的aop使用代码
好的,以下是一个简单的 Spring Boot 2.5.4 AOP 的使用示例代码:
1. 创建一个切面类(Aspect Class):
```java
@Aspect
@Component
public class MyAspect {
@Before("execution(* com.example.demo.controller.*.*(..))")
public void beforeAdvice(JoinPoint joinPoint) {
System.out.println("Before method:" + joinPoint.getSignature());
}
@After("execution(* com.example.demo.controller.*.*(..))")
public void afterAdvice(JoinPoint joinPoint) {
System.out.println("After method:" + joinPoint.getSignature());
}
}
```
2. 在 Spring Boot 的配置类中启用 AOP:
```java
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
}
```
3. 在控制器(Controller)中使用 AOP:
```java
@RestController
@RequestMapping("/api")
public class MyController {
@GetMapping("/hello")
@MyAnnotation
public String hello() {
return "Hello, World!";
}
}
```
4. 创建一个自定义注解(Annotation):
```java
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
}
```
这个示例中,我们创建了一个切面类 `MyAspect`,并在其中定义了 `beforeAdvice` 和 `afterAdvice` 两个通知(Advice),用于在控制器中的方法执行前后打印日志。我们使用 `@Aspect` 注解将该类标记为切面类,并使用 `@Before` 和 `@After` 注解分别定义了 `beforeAdvice` 和 `afterAdvice` 两个通知。通知方法中使用了 `JoinPoint` 类型的参数来获取连接点(Join Point)的信息,从而进行适当的处理。
我们在 Spring Boot 的配置类 `AppConfig` 中启用了 AOP,使用了 `@EnableAspectJAutoProxy` 注解开启了自动代理功能。
在控制器中,我们使用了 `@MyAnnotation` 自定义注解来标记 `hello` 方法,这样我们就可以在切面类中通过 `@MyAnnotation` 来匹配该方法,从而进行相应的处理。
需要注意的是,我们使用了 `execution(* com.example.demo.controller.*.*(..))` 表达式来匹配控制器中的所有方法,其中 `com.example.demo.controller` 是控制器所在的包名。这个表达式的意思是,匹配该包中的所有类的所有方法,并且方法的参数可以是任意类型、任意个数。你可以根据实际情况来修改这个表达式,以达到更精确的匹配。
这就是一个简单的 Spring Boot 2.5.4 AOP 的使用示例代码。希望能对你有所帮助!