myplayer/myplayer-server
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

legacy repo

Browse Source
This commit is contained in:
merlin
2026-03-09 10:51:16 +08:00
parent 1c32c61f22
commit 0d01b191bb
63 changed files with 2928 additions and 2928 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
.gitignore vendored
View File

@@ -1,33 +1,33 @@
HELP.md HELP.md
target/ target/
!.mvn/wrapper/maven-wrapper.jar !.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/ !**/src/main/**/target/
!**/src/test/**/target/ !**/src/test/**/target/
### STS ### ### STS ###
.apt_generated .apt_generated
.classpath .classpath
.factorypath .factorypath
.project .project
.settings .settings
.springBeans .springBeans
.sts4-cache .sts4-cache
### IntelliJ IDEA ### ### IntelliJ IDEA ###
.idea .idea
*.iws *.iws
*.iml *.iml
*.ipr *.ipr
### NetBeans ### ### NetBeans ###
/nbproject/private/ /nbproject/private/
/nbbuild/ /nbbuild/
/dist/ /dist/
/nbdist/ /nbdist/
/.nb-gradle/ /.nb-gradle/
build/ build/
!**/src/main/**/build/ !**/src/main/**/build/
!**/src/test/**/build/ !**/src/test/**/build/
### VS Code ### ### VS Code ###
.vscode/ .vscode/

384
pom.xml
View File

@@ -1,193 +1,193 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" <project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId> <groupId>com.example</groupId>
<artifactId>MyPlayer_server</artifactId> <artifactId>MyPlayer_server</artifactId>
<version>0.0.1-SNAPSHOT</version> <version>0.0.1-SNAPSHOT</version>
<name>MyPlayer_server</name> <name>MyPlayer_server</name>
<description>MyPlayer_server</description> <description>MyPlayer_server</description>
<properties> <properties>
<java.version>1.8</java.version> <java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<spring-boot.version>2.6.13</spring-boot.version> <spring-boot.version>2.6.13</spring-boot.version>
</properties> </properties>
<dependencies> <dependencies>
<!-- <dependency>--> <!-- <dependency>-->
<!-- <groupId>org.springframework.boot</groupId>--> <!-- <groupId>org.springframework.boot</groupId>-->
<!-- <artifactId>spring-boot-starter-mail</artifactId>--> <!-- <artifactId>spring-boot-starter-mail</artifactId>-->
<!-- </dependency>--> <!-- </dependency>-->
<!-- <dependency>--> <!-- <dependency>-->
<!-- <groupId>org.springframework.boot</groupId>--> <!-- <groupId>org.springframework.boot</groupId>-->
<!-- <artifactId>spring-boot-starter-quartz</artifactId>--> <!-- <artifactId>spring-boot-starter-quartz</artifactId>-->
<!-- </dependency>--> <!-- </dependency>-->
<!-- <dependency>--> <!-- <dependency>-->
<!-- <groupId>org.springframework.boot</groupId>--> <!-- <groupId>org.springframework.boot</groupId>-->
<!-- <artifactId>spring-boot-starter-security</artifactId>--> <!-- <artifactId>spring-boot-starter-security</artifactId>-->
<!-- </dependency>--> <!-- </dependency>-->
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId> <artifactId>spring-boot-starter-web</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.alibaba</groupId> <groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId> <artifactId>fastjson</artifactId>
<version>1.2.78</version> <version>1.2.78</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId> <artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope> <scope>runtime</scope>
<optional>true</optional> <optional>true</optional>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId> <artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional> <optional>true</optional>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.projectlombok</groupId> <groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId> <artifactId>lombok</artifactId>
<optional>true</optional> <optional>true</optional>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId> <artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.springframework.security</groupId> <groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId> <artifactId>spring-security-test</artifactId>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency> <dependency>
<groupId>ch.qos.logback</groupId> <groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId> <artifactId>logback-classic</artifactId>
<version>1.2.11</version> <version>1.2.11</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.mysql</groupId> <groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId> <artifactId>mysql-connector-j</artifactId>
<version>9.0.0</version> <version>9.0.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.jsoup</groupId> <groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId> <artifactId>jsoup</artifactId>
<version>1.15.1</version> <version>1.15.1</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.baomidou</groupId> <groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId> <artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.7</version> <version>3.5.7</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>junit</groupId> <groupId>junit</groupId>
<artifactId>junit</artifactId> <artifactId>junit</artifactId>
<version>4.13.2</version> <version>4.13.2</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.alibaba</groupId> <groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId> <artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.22</version> <version>1.2.22</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId> <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>io.lettuce</groupId> <groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId> <artifactId>lettuce-core</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.auth0</groupId> <groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId> <artifactId>java-jwt</artifactId>
<version>4.4.0</version> <version>4.4.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.aliyun.oss</groupId> <groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-sdk-oss</artifactId> <artifactId>aliyun-sdk-oss</artifactId>
<version>3.18.0</version> <version>3.18.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>commons-io</groupId> <groupId>commons-io</groupId>
<artifactId>commons-io</artifactId> <artifactId>commons-io</artifactId>
<version>2.5</version> <version>2.5</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>commons-beanutils</groupId> <groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId> <artifactId>commons-beanutils</artifactId>
<version>1.9.3</version> <version>1.9.3</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId> <artifactId>spring-boot-starter-websocket</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId> <artifactId>spring-boot-starter-mail</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.github.ben-manes.caffeine</groupId> <groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId> <artifactId>caffeine</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.json</groupId> <groupId>org.json</groupId>
<artifactId>json</artifactId> <artifactId>json</artifactId>
<version>20210307</version> <version>20231013</version>
</dependency> </dependency>
</dependencies> </dependencies>
<dependencyManagement> <dependencyManagement>
<dependencies> <dependencies>
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId> <artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version> <version>${spring-boot.version}</version>
<type>pom</type> <type>pom</type>
<scope>import</scope> <scope>import</scope>
</dependency> </dependency>
</dependencies> </dependencies>
</dependencyManagement> </dependencyManagement>
<build> <build>
<plugins> <plugins>
<plugin> <plugin>
<groupId>org.apache.maven.plugins</groupId> <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId> <artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version> <version>3.8.1</version>
<configuration> <configuration>
<source>1.8</source> <source>1.8</source>
<target>1.8</target> <target>1.8</target>
<encoding>UTF-8</encoding> <encoding>UTF-8</encoding>
</configuration> </configuration>
</plugin> </plugin>
<plugin> <plugin>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId> <artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version> <version>${spring-boot.version}</version>
<executions> <executions>
<execution> <execution>
<goals> <goals>
<goal>repackage</goal> <goal>repackage</goal>
</goals> </goals>
</execution> </execution>
</executions> </executions>
</plugin> </plugin>
</plugins> </plugins>
</build> </build>
</project> </project>

28
src/main/java/myplayer/MyPlayerServerApplication.java
View File

@@ -1,14 +1,14 @@
package myplayer; package myplayer;
import org.springframework.boot.SpringApplication; import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication @SpringBootApplication
public class MyPlayerServerApplication { public class MyPlayerServerApplication {
public static void main(String[] args) { public static void main(String[] args) {
SpringApplication.run(MyPlayerServerApplication.class, args); SpringApplication.run(MyPlayerServerApplication.class, args);
} }
} }

48
src/main/java/myplayer/config/CorsConfig.java
View File

@@ -1,24 +1,24 @@
package myplayer.config; package myplayer.config;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry; import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration @Configuration
public class CorsConfig { public class CorsConfig {
@Bean @Bean
public WebMvcConfigurer corsConfigurer() { public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurer() { return new WebMvcConfigurer() {
@Override @Override
public void addCorsMappings(CorsRegistry registry) { public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**") registry.addMapping("/**")
.allowedOrigins("*") .allowedOrigins("*")
.allowedMethods("GET","POST","PUT","DELETE","OPTIONS") .allowedMethods("GET","POST","PUT","DELETE","OPTIONS")
.allowedHeaders("*"); .allowedHeaders("*");
} }
}; };
} }
} }

54
src/main/java/myplayer/config/Interceptor.java
View File

@@ -1,27 +1,27 @@
package myplayer.config; package myplayer.config;
import myplayer.utils.Jwt; import myplayer.utils.Jwt;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.Map; import java.util.Map;
@Component @Component
public class Interceptor implements HandlerInterceptor { public class Interceptor implements HandlerInterceptor {
@Override @Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String token = request.getHeader("Authorization"); String token = request.getHeader("Authorization");
//验证token //验证token
try { try {
Map<String,Object> claims = Jwt.parseToken(token); Map<String,Object> claims = Jwt.parseToken(token);
//验证成功，放行 //验证成功，放行
return true; return true;
} catch (Exception e) { } catch (Exception e) {
response.setStatus(401); response.setStatus(401);
//验证失败，不放行 //验证失败，不放行
return false; return false;
} }
} }
} }

32
src/main/java/myplayer/config/MyBatisPlusConfig.java
View File

@@ -1,17 +1,17 @@
package myplayer.config; package myplayer.config;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
@Configuration @Configuration
public class MyBatisPlusConfig { public class MyBatisPlusConfig {
@Bean @Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() { public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new PaginationInnerInterceptor()); interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return interceptor; return interceptor;
} }
} }

70
src/main/java/myplayer/config/RedisConfig.java
View File

@@ -1,35 +1,35 @@
package myplayer.config; package myplayer.config;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer; import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer; import org.springframework.data.redis.serializer.RedisSerializer;
@Configuration @Configuration
public class RedisConfig { public class RedisConfig {
//配置StringRedisTemplate，用于操作String类型的数据 //配置StringRedisTemplate，用于操作String类型的数据
@Bean @Bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) { public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
StringRedisTemplate template = new StringRedisTemplate(redisConnectionFactory); StringRedisTemplate template = new StringRedisTemplate(redisConnectionFactory);
template.setKeySerializer(RedisSerializer.string()); template.setKeySerializer(RedisSerializer.string());
template.setValueSerializer(RedisSerializer.string()); template.setValueSerializer(RedisSerializer.string());
return template; return template;
} }
//配置RedisTemplate，用于操作更复杂的对象 //配置RedisTemplate，用于操作更复杂的对象
@Bean @Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>(); RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory); template.setConnectionFactory(redisConnectionFactory);
template.setKeySerializer(RedisSerializer.string()); template.setKeySerializer(RedisSerializer.string());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); //使用Jackson序列化器 template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); //使用Jackson序列化器
return template; return template;
} }
} }

50
src/main/java/myplayer/config/RequestConfig.java
View File

@@ -1,25 +1,25 @@
package myplayer.config; package myplayer.config;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration @Configuration
public class RequestConfig implements WebMvcConfigurer { public class RequestConfig implements WebMvcConfigurer {
@Autowired @Autowired
private Interceptor logininterceptor; private Interceptor logininterceptor;
@Override @Override
public void addInterceptors(InterceptorRegistry registry) { public void addInterceptors(InterceptorRegistry registry) {
//配置接口不拦截 //配置接口不拦截
registry.addInterceptor(logininterceptor).excludePathPatterns( registry.addInterceptor(logininterceptor).excludePathPatterns(
"/register", "/register",
"/login", "/login",
"/test/hello", "/test/hello",
"/chat", "/chat",
"/code/sendcode", "/code/sendcode",
"/code/verifycode"); "/code/verifycode");
} }
} }

8
src/main/java/myplayer/config/SecurityConfig.java
View File

@@ -1,4 +1,4 @@
package myplayer.config; package myplayer.config;
public class SecurityConfig { public class SecurityConfig {
} }

64
src/main/java/myplayer/config/WebSocketHandshakeInterceptor.java
View File

@@ -1,32 +1,32 @@
package myplayer.config; package myplayer.config;
import org.springframework.http.server.ServerHttpRequest; import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse; import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest; import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler; import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor; import org.springframework.web.socket.server.HandshakeInterceptor;
import java.util.Map; import java.util.Map;
// WebSocket握手拦截器 // WebSocket握手拦截器
public class WebSocketHandshakeInterceptor implements HandshakeInterceptor { public class WebSocketHandshakeInterceptor implements HandshakeInterceptor {
@Override @Override
public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception { public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
// 解析URL中的u_id参数 // 解析URL中的u_id参数
if (request instanceof ServletServerHttpRequest) { if (request instanceof ServletServerHttpRequest) {
ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request; ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
String userId = servletRequest.getServletRequest().getParameter("u_id"); String userId = servletRequest.getServletRequest().getParameter("u_id");
String userName = servletRequest.getServletRequest().getParameter("u_name"); String userName = servletRequest.getServletRequest().getParameter("u_name");
if (userId != null && userName != null) { if (userId != null && userName != null) {
attributes.put("u_id", userId); // 将u_id存储到Attributes中 attributes.put("u_id", userId); // 将u_id存储到Attributes中
attributes.put("u_name", userName); // 将u_name存储到Attributes中 attributes.put("u_name", userName); // 将u_name存储到Attributes中
} }
} }
return true; return true;
} }
@Override @Override
public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) { public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
// 可选：在连接建立后执行一些操作 // 可选：在连接建立后执行一些操作
} }
} }

68
src/main/java/myplayer/config/WebsocketConfig.java
View File

@@ -1,34 +1,34 @@
package myplayer.config; package myplayer.config;
import myplayer.utils.webRTC.WebRTCSignalHandler; import myplayer.utils.webRTC.WebRTCSignalHandler;
import myplayer.utils.websocket.OnlineStatus; import myplayer.utils.websocket.OnlineStatus;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket; import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer; import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry; import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
@Configuration @Configuration
@EnableWebSocket @EnableWebSocket
public class WebsocketConfig implements WebSocketConfigurer { public class WebsocketConfig implements WebSocketConfigurer {
@Autowired @Autowired
private OnlineStatus onlineStatusHandler; private OnlineStatus onlineStatusHandler;
@Autowired @Autowired
private WebRTCSignalHandler webRTCSignalHandler; private WebRTCSignalHandler webRTCSignalHandler;
@Override @Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(onlineStatusHandler, "/online").setAllowedOrigins("*") registry.addHandler(onlineStatusHandler, "/online").setAllowedOrigins("*")
.addInterceptors(new WebSocketHandshakeInterceptor()); //注册online节点 .addInterceptors(new WebSocketHandshakeInterceptor()); //注册online节点
registry.addHandler(webRTCSignalHandler,"/voice").setAllowedOrigins("*") registry.addHandler(webRTCSignalHandler,"/voice").setAllowedOrigins("*")
.addInterceptors(new WebSocketHandshakeInterceptor()); .addInterceptors(new WebSocketHandshakeInterceptor());
} }
} }

134
src/main/java/myplayer/controller/AvatarController.java
View File

@@ -1,68 +1,68 @@
package myplayer.controller; package myplayer.controller;
//import myplayer.service.UserInfoService; //import myplayer.service.UserInfoService;
//import myplayer.utils.AliyunOSS; //import myplayer.utils.AliyunOSS;
//import myplayer.utils.Jwt; //import myplayer.utils.Jwt;
//import myplayer.utils.Result; //import myplayer.utils.Result;
//import org.springframework.beans.factory.annotation.Autowired; //import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.web.bind.annotation.PostMapping; //import org.springframework.web.bind.annotation.PostMapping;
//import org.springframework.web.bind.annotation.RequestHeader; //import org.springframework.web.bind.annotation.RequestHeader;
//import org.springframework.web.bind.annotation.RequestMapping; //import org.springframework.web.bind.annotation.RequestMapping;
//import org.springframework.web.bind.annotation.RestController; //import org.springframework.web.bind.annotation.RestController;
//import org.springframework.web.multipart.MultipartFile; //import org.springframework.web.multipart.MultipartFile;
// //
//import java.io.IOException; //import java.io.IOException;
//import java.util.Map; //import java.util.Map;
// //
//@RestController //@RestController
//@RequestMapping //@RequestMapping
//public class AvatarController { //public class AvatarController {
// //
// @Autowired // @Autowired
// UserInfoService userInfoService; // UserInfoService userInfoService;
// //
// @PostMapping("/uploadavatar") // @PostMapping("/uploadavatar")
// public Result uploadAvatar(@RequestHeader("Authorization") String token, MultipartFile avatar) throws IOException { // public Result uploadAvatar(@RequestHeader("Authorization") String token, MultipartFile avatar) throws IOException {
// try { // try {
// Map<String,Object> map = Jwt.parseToken(token); // Map<String,Object> map = Jwt.parseToken(token);
// String u_id = (String) map.get("u_id"); // String u_id = (String) map.get("u_id");
// if(avatar==null) return Result.error("图片为空"); // if(avatar==null) return Result.error("图片为空");
// String oldProfile = userInfoService.getProfile(u_id); // String oldProfile = userInfoService.getProfile(u_id);
// if(oldProfile!=null && !oldProfile.equals("https://for-ever.oss-cn-guangzhou.aliyuncs.com/myplayer/avatar.jpg")) AliyunOSS.deleteImage(oldProfile); // if(oldProfile!=null && !oldProfile.equals("https://for-ever.oss-cn-guangzhou.aliyuncs.com/myplayer/avatar.jpg")) AliyunOSS.deleteImage(oldProfile);
// String profile = AliyunOSS.uploadImage(avatar); // String profile = AliyunOSS.uploadImage(avatar);
// if(userInfoService.updateProfile(u_id,profile)==1) // if(userInfoService.updateProfile(u_id,profile)==1)
// return Result.success("上传成功！"); // return Result.success("上传成功！");
// return Result.error("上传失败！"); // return Result.error("上传失败！");
// } catch (IOException e) { // } catch (IOException e) {
// return Result.error("上传失败！换张图片试试吧！"); // return Result.error("上传失败！换张图片试试吧！");
// } // }
// } // }
// //
//} //}
import myplayer.service.AvatarService; import myplayer.service.AvatarService;
import myplayer.utils.Result; import myplayer.utils.Result;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import java.io.IOException; import java.io.IOException;
@RestController @RestController
@RequestMapping("/avatar") @RequestMapping("/avatar")
public class AvatarController { public class AvatarController {
@Autowired @Autowired
private AvatarService avatarService; private AvatarService avatarService;
@PostMapping("/upload") @PostMapping("/upload")
public Result uploadAvatar(@RequestParam("file") MultipartFile file, public Result uploadAvatar(@RequestParam("file") MultipartFile file,
@RequestParam("id") String Id) { @RequestParam("id") String Id) {
try { try {
String url = avatarService.storeAvatar(file, Id); String url = avatarService.storeAvatar(file, Id);
return Result.success("上传成功",url); return Result.success("上传成功",url);
} catch (IOException e) { } catch (IOException e) {
System.out.println(e.getMessage()); System.out.println(e.getMessage());
return Result.error("上传失败"); return Result.error("上传失败");
} }
} }
} }

114
src/main/java/myplayer/controller/FriendController.java
View File

@@ -1,57 +1,57 @@
package myplayer.controller; package myplayer.controller;
import myplayer.entity.Inviting; import myplayer.entity.Inviting;
import myplayer.entity.User; import myplayer.entity.User;
import myplayer.service.FriendService; import myplayer.service.FriendService;
import myplayer.service.InvitingService; import myplayer.service.InvitingService;
import myplayer.service.UserService; import myplayer.service.UserService;
import myplayer.utils.Jwt; import myplayer.utils.Jwt;
import myplayer.utils.Result; import myplayer.utils.Result;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import java.util.List; import java.util.List;
@RestController @RestController
@RequestMapping("/friend") @RequestMapping("/friend")
public class FriendController { public class FriendController {
@Autowired @Autowired
private UserService userService; private UserService userService;
@Autowired @Autowired
private FriendService friendService; private FriendService friendService;
@GetMapping("/getfriends") @GetMapping("/getfriends")
public Result getFriends(@RequestHeader("Authorization") String token){ public Result getFriends(@RequestHeader("Authorization") String token){
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
List<User> Users = friendService.getFriends(u_id); List<User> Users = friendService.getFriends(u_id);
return Result.success("获取成功",Users); return Result.success("获取成功",Users);
} }
@GetMapping("/searchuser") @GetMapping("/searchuser")
public Result search(@RequestHeader("Authorization") String token,@RequestParam String u_name){ public Result search(@RequestHeader("Authorization") String token,@RequestParam String u_name){
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
List<User> users = userService.search(u_id,u_name); List<User> users = userService.search(u_id,u_name);
return Result.success("",users); return Result.success("",users);
} }
@PostMapping("/deletefriend") @PostMapping("/deletefriend")
public Result deleteFriend(@RequestHeader("Authorization") String token,@RequestBody User user){ public Result deleteFriend(@RequestHeader("Authorization") String token,@RequestBody User user){
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
String f_id= user.getU_id(); String f_id= user.getU_id();
friendService.removeFriend(u_id,f_id); friendService.removeFriend(u_id,f_id);
return Result.success("删除成功"); return Result.success("删除成功");
} }
} }

236
src/main/java/myplayer/controller/GroupController.java
View File

@@ -1,118 +1,118 @@
package myplayer.controller; package myplayer.controller;
import myplayer.entity.Groupchat; import myplayer.entity.Groupchat;
import myplayer.entity.Grouprelation; import myplayer.entity.Grouprelation;
import myplayer.service.GroupService; import myplayer.service.GroupService;
import myplayer.utils.Jwt; import myplayer.utils.Jwt;
import myplayer.utils.RandomCode; import myplayer.utils.RandomCode;
import myplayer.utils.Result; import myplayer.utils.Result;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@RestController @RestController
@RequestMapping("/group") @RequestMapping("/group")
public class GroupController { public class GroupController {
@Autowired @Autowired
private GroupService groupService; private GroupService groupService;
@PostMapping("/create") @PostMapping("/create")
public Result createGroup(@RequestHeader("Authorization") String token, @RequestBody Groupchat groupchat) { public Result createGroup(@RequestHeader("Authorization") String token, @RequestBody Groupchat groupchat) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
String g_id; String g_id;
do { do {
g_id = "G" + RandomCode.generateID(); g_id = "G" + RandomCode.generateID();
} while (groupService.groupIsExist(g_id) == 1); } while (groupService.groupIsExist(g_id) == 1);
groupchat.setG_id(g_id); groupchat.setG_id(g_id);
try { try {
groupService.createGroup(groupchat, u_id); groupService.createGroup(groupchat, u_id);
} catch (Exception e) { } catch (Exception e) {
System.out.println(LocalDateTime.now() + " " + e); System.out.println(LocalDateTime.now() + " " + e);
return Result.error(e.getMessage()); return Result.error(e.getMessage());
} }
return Result.success("创建成功"); return Result.success("创建成功");
} }
@GetMapping("/search") @GetMapping("/search")
public Result searchGroup(@RequestHeader("Authorization") String token, @RequestParam String g_name) { public Result searchGroup(@RequestHeader("Authorization") String token, @RequestParam String g_name) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
return Result.success("搜索到", groupService.searchGroups(u_id, g_name)); return Result.success("搜索到", groupService.searchGroups(u_id, g_name));
} }
@PostMapping("/joingroup") @PostMapping("/joingroup")
public Result joingroup(@RequestHeader("Authorization") String token, @RequestBody Groupchat groupchat) { public Result joingroup(@RequestHeader("Authorization") String token, @RequestBody Groupchat groupchat) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
groupService.joinGroup(u_id, groupchat.getG_id()); groupService.joinGroup(u_id, groupchat.getG_id());
return Result.success("加入成功"); return Result.success("加入成功");
} }
@GetMapping("/getgroups") @GetMapping("/getgroups")
public Result getGroups(@RequestHeader("Authorization") String token) { public Result getGroups(@RequestHeader("Authorization") String token) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
return Result.success("获取成功", groupService.getGroups(u_id)); return Result.success("获取成功", groupService.getGroups(u_id));
} }
@GetMapping("/leave") @GetMapping("/leave")
public Result leave(@RequestHeader("Authorization") String token, @RequestParam String g_id) { public Result leave(@RequestHeader("Authorization") String token, @RequestParam String g_id) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
groupService.leave(u_id, g_id); groupService.leave(u_id, g_id);
return Result.success("离开成功"); return Result.success("离开成功");
} }
@PostMapping("/setnote") @PostMapping("/setnote")
public Result setnote(@RequestHeader("Authorization") String token, @RequestBody Groupchat groupchat) { public Result setnote(@RequestHeader("Authorization") String token, @RequestBody Groupchat groupchat) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
if (groupService.setNote(u_id, groupchat)) { if (groupService.setNote(u_id, groupchat)) {
return Result.success("设置成功"); return Result.success("设置成功");
} else { } else {
return Result.success("设置失败"); return Result.success("设置失败");
} }
} }
@PostMapping("/rmnote") @PostMapping("/rmnote")
public Result rmnote(@RequestHeader("Authorization") String token, @RequestBody Groupchat groupchat) { public Result rmnote(@RequestHeader("Authorization") String token, @RequestBody Groupchat groupchat) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
if (groupService.setNote(u_id, groupchat)) { if (groupService.setNote(u_id, groupchat)) {
return Result.success("移除成功"); return Result.success("移除成功");
} else { } else {
return Result.success("移除失败"); return Result.success("移除失败");
} }
} }
@PostMapping("/setname") @PostMapping("/setname")
public Result setname(@RequestBody Groupchat groupchat) { public Result setname(@RequestBody Groupchat groupchat) {
groupService.setName(groupchat.getG_id(), groupchat.getG_name()); groupService.setName(groupchat.getG_id(), groupchat.getG_name());
return Result.success("修改成功"); return Result.success("修改成功");
} }
@GetMapping("/getmember/{g_id}") @GetMapping("/getmember/{g_id}")
public Result getMember(@PathVariable String g_id) { public Result getMember(@PathVariable String g_id) {
return Result.success("获取成功", groupService.getMembers(g_id)); return Result.success("获取成功", groupService.getMembers(g_id));
} }
@PostMapping("/setrole") @PostMapping("/setrole")
public Result setrole(@RequestHeader("Authorization") String token, @RequestBody Grouprelation grouprelation) { public Result setrole(@RequestHeader("Authorization") String token, @RequestBody Grouprelation grouprelation) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
if (groupService.setRole(u_id, grouprelation)) if (groupService.setRole(u_id, grouprelation))
return Result.success("设置成功"); return Result.success("设置成功");
else else
return Result.error("设置失败"); return Result.error("设置失败");
} }
@PostMapping("/kick") @PostMapping("/kick")
public Result kick(@RequestHeader("Authorization")String token , @RequestBody Grouprelation grouprelation) { public Result kick(@RequestHeader("Authorization")String token , @RequestBody Grouprelation grouprelation) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
if(groupService.verifyRole(u_id,grouprelation.getG_id())==2) return Result.error("权限不足"); if(groupService.verifyRole(u_id,grouprelation.getG_id())==2) return Result.error("权限不足");
groupService.leave(grouprelation.getU_id(),grouprelation.getG_id()); groupService.leave(grouprelation.getU_id(),grouprelation.getG_id());
return Result.success("踢出成功"); return Result.success("踢出成功");
} }
} }

212
src/main/java/myplayer/controller/InvitingController.java
View File

@@ -1,106 +1,106 @@
package myplayer.controller; package myplayer.controller;
import com.github.benmanes.caffeine.cache.Cache; import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.Caffeine;
import myplayer.entity.Inviting; import myplayer.entity.Inviting;
import myplayer.entity.Own; import myplayer.entity.Own;
import myplayer.service.FriendService; import myplayer.service.FriendService;
import myplayer.service.InvitingService; import myplayer.service.InvitingService;
import myplayer.service.OwnService; import myplayer.service.OwnService;
import myplayer.utils.Jwt; import myplayer.utils.Jwt;
import myplayer.utils.RandomCode; import myplayer.utils.RandomCode;
import myplayer.utils.Result; import myplayer.utils.Result;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@RestController @RestController
@RequestMapping("/inviting") @RequestMapping("/inviting")
public class InvitingController { public class InvitingController {
private static final Cache<String, String> invitingCode = Caffeine.newBuilder() private static final Cache<String, String> invitingCode = Caffeine.newBuilder()
.expireAfterWrite(5, TimeUnit.MINUTES) .expireAfterWrite(5, TimeUnit.MINUTES)
.build(); .build();
@Autowired @Autowired
private InvitingService invitingService; private InvitingService invitingService;
@Autowired @Autowired
private FriendService friendService; private FriendService friendService;
@Autowired @Autowired
private OwnService ownService; private OwnService ownService;
@PostMapping("/sendinviting") @PostMapping("/sendinviting")
public Result sendInvite(@RequestHeader("Authorization") String token, @RequestBody Inviting inviting) { public Result sendInvite(@RequestHeader("Authorization") String token, @RequestBody Inviting inviting) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
if(inviting.getRoom()==null){ if(inviting.getRoom()==null){
if(invitingService.sendInvite(u_id, inviting.getTarget(), null) == 0 ) if(invitingService.sendInvite(u_id, inviting.getTarget(), null) == 0 )
return Result.error("请勿重复发送"); return Result.error("请勿重复发送");
} }
else{ else{
if (invitingService.sendInvite(u_id, inviting.getTarget(), inviting.getRoom()) == 0) if (invitingService.sendInvite(u_id, inviting.getTarget(), inviting.getRoom()) == 0)
return Result.error("请勿重复发送"); return Result.error("请勿重复发送");
} }
System.out.println(u_id + "------>" + inviting.getTarget()); System.out.println(u_id + "------>" + inviting.getTarget());
return Result.success("发送成功"); return Result.success("发送成功");
} }
@GetMapping("/getinvitings") @GetMapping("/getinvitings")
public Result getInvitings(@RequestHeader("Authorization") String token) { public Result getInvitings(@RequestHeader("Authorization") String token) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
return Result.success("获取成功", invitingService.getInvitings(u_id)); return Result.success("获取成功", invitingService.getInvitings(u_id));
} }
@GetMapping("/getinvitings/{r_id}") @GetMapping("/getinvitings/{r_id}")
public Result getJoinRequest(@PathVariable String r_id) { public Result getJoinRequest(@PathVariable String r_id) {
return Result.success("success", invitingService.getJoinRequest(r_id)); return Result.success("success", invitingService.getJoinRequest(r_id));
} }
@PostMapping("/passinviting") @PostMapping("/passinviting")
public Result passInvite(@RequestBody Inviting inviting) { public Result passInvite(@RequestBody Inviting inviting) {
if (inviting.getRoom() != null) { if (inviting.getRoom() != null) {
invitingService.acceptInvite(inviting, inviting.getRoom()); invitingService.acceptInvite(inviting, inviting.getRoom());
} else { } else {
invitingService.acceptInvite(inviting); invitingService.acceptInvite(inviting);
friendService.addFriend(inviting.getInviter(), inviting.getTarget()); friendService.addFriend(inviting.getInviter(), inviting.getTarget());
} }
return Result.success("接受成功"); return Result.success("接受成功");
} }
@PostMapping("/refuseinviting") @PostMapping("/refuseinviting")
public Result refuseInvite(@RequestBody Inviting inviting) { public Result refuseInvite(@RequestBody Inviting inviting) {
if (inviting.getRoom() != null) { if (inviting.getRoom() != null) {
invitingService.refuseInvite(inviting, inviting.getRoom()); invitingService.refuseInvite(inviting, inviting.getRoom());
} else { } else {
invitingService.refuseInvite(inviting); invitingService.refuseInvite(inviting);
} }
return Result.success("接受成功"); return Result.success("接受成功");
} }
//房主或者管理员生成邀请码请求 供用户加入房间使用，简化加入房间的审核机制 //房主或者管理员生成邀请码请求 供用户加入房间使用，简化加入房间的审核机制
@PostMapping("/createinvitingcode") @PostMapping("/createinvitingcode")
public Result createInvitingCode(@RequestHeader("Authorization") String token, @RequestBody Own own) { public Result createInvitingCode(@RequestHeader("Authorization") String token, @RequestBody Own own) {
if (own.getRole() == 2) return Result.error("权限不足"); if (own.getRole() == 2) return Result.error("权限不足");
String code = RandomCode.generateMassiveCode(); String code = RandomCode.generateMassiveCode();
invitingCode.put(code, own.getR_id()); invitingCode.put(code, own.getR_id());
return Result.success("生成成功", code); return Result.success("生成成功", code);
} }
//验证通过邀请码加入房间 //验证通过邀请码加入房间
@PostMapping("/checkinvitingcode") @PostMapping("/checkinvitingcode")
public Result checkInvitingCode(@RequestHeader("Authorization") String token, @RequestParam String code) { public Result checkInvitingCode(@RequestHeader("Authorization") String token, @RequestParam String code) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
String r_id = invitingCode.getIfPresent(code); String r_id = invitingCode.getIfPresent(code);
if (r_id == null) return Result.error("邀请码无效"); if (r_id == null) return Result.error("邀请码无效");
ownService.joinRoom(u_id, r_id); ownService.joinRoom(u_id, r_id);
return Result.success("加入成功"); return Result.success("加入成功");
} }
} }

212
src/main/java/myplayer/controller/LoginController.java
View File

@@ -1,106 +1,106 @@
package myplayer.controller; package myplayer.controller;
import myplayer.entity.Account; import myplayer.entity.Account;
import myplayer.entity.User; import myplayer.entity.User;
import myplayer.mapper.AccountMapper; import myplayer.mapper.AccountMapper;
import myplayer.mapper.UserMapper; import myplayer.mapper.UserMapper;
import myplayer.service.AccountService; import myplayer.service.AccountService;
import myplayer.service.UserService; import myplayer.service.UserService;
import myplayer.utils.*; import myplayer.utils.*;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import static myplayer.utils.Jwt.genToken; import static myplayer.utils.Jwt.genToken;
import static myplayer.utils.Jwt.getU_id; import static myplayer.utils.Jwt.getU_id;
@RestController @RestController
@RequestMapping @RequestMapping
public class LoginController { public class LoginController {
@Autowired @Autowired
private UserService userService; private UserService userService;
@Autowired @Autowired
private AccountService accountService; private AccountService accountService;
@PostMapping("/register") @PostMapping("/register")
Result register(@RequestBody Account account) { Result register(@RequestBody Account account) {
//服务器保护机制 //服务器保护机制
if(account.getU_account()==null || account.getU_password()==null) return Result.error("未输入账号和密码"); if(account.getU_account()==null || account.getU_password()==null) return Result.error("未输入账号和密码");
if(accountService.isExist(account.getU_account())>=1) return Result.createError("注册失败，邮箱已被注册！"); if(accountService.isExist(account.getU_account())>=1) return Result.createError("注册失败，邮箱已被注册！");
//确认u_id未重复 //确认u_id未重复
String id; String id;
int i=0;//超时tag int i=0;//超时tag
do{ do{
id = "U"+ RandomCode.generateID(); id = "U"+ RandomCode.generateID();
i++; i++;
if(i==20) break; if(i==20) break;
} }
while(accountService.idIsExist(id)); while(accountService.idIsExist(id));
//分配u_id：U+6位数字组合 //分配u_id：U+6位数字组合
account.setU_id(id); account.setU_id(id);
System.out.println(account.getU_id()); System.out.println(account.getU_id());
//对密码进行加密储存 //对密码进行加密储存
//account.setU_password(Md5.getMD5String(account.getU_password())); //account.setU_password(Md5.getMD5String(account.getU_password()));
account.setU_password(SHA256Util.encryptPasswordWithUserId(account.getU_password(), account.getU_id())); account.setU_password(SHA256Util.encryptPasswordWithUserId(account.getU_password(), account.getU_id()));
//写入表 //写入表
accountService.insert(account); accountService.insert(account);
userService.initUser(account.getU_id()); userService.initUser(account.getU_id());
return Result.success("注册成功!"); return Result.success("注册成功!");
} }
@PostMapping("/login") @PostMapping("/login")
Result login(@RequestBody Account account, @RequestHeader(value="X-Forwarded-For",defaultValue = "") String clientIP, HttpServletRequest request) { Result login(@RequestBody Account account, @RequestHeader(value="X-Forwarded-For",defaultValue = "") String clientIP, HttpServletRequest request) {
//查询账号是否存在 //查询账号是否存在
String u_account = account.getU_account(); String u_account = account.getU_account();
if(accountService.isExist(u_account)==0){ if(accountService.isExist(u_account)==0){
return Result.accountError("账号不存在！"); return Result.accountError("账号不存在！");
} }
//加密密码并核对 //加密密码并核对
account.setU_id(accountService.getUId(u_account)); account.setU_id(accountService.getUId(u_account));
if(!SHA256Util.encryptPasswordWithUserId(account.getU_password(), account.getU_id()) if(!SHA256Util.encryptPasswordWithUserId(account.getU_password(), account.getU_id())
.equals(accountService.verifyPassword(account.getU_account()))){ .equals(accountService.verifyPassword(account.getU_account()))){
return Result.accountError("密码错误"); return Result.accountError("密码错误");
} }
//验证通过，生成jwt代码 //验证通过，生成jwt代码
//设置jwt令牌 //设置jwt令牌
Map<String,Object> claim = new HashMap<>(); Map<String,Object> claim = new HashMap<>();
claim.put("u_id",account.getU_id()); claim.put("u_id",account.getU_id());
claim.put("u_account",account.getU_account()); claim.put("u_account",account.getU_account());
String token = genToken(claim); String token = genToken(claim);
if(clientIP==null||clientIP.isEmpty()){ if(clientIP==null||clientIP.isEmpty()){
clientIP=request.getRemoteAddr(); clientIP=request.getRemoteAddr();
} }
accountService.updateIP(account.getU_id(),clientIP); accountService.updateIP(account.getU_id(),clientIP);
System.out.println( LocalDateTime.now() +"login:"+u_account+" IP:"+clientIP); System.out.println( LocalDateTime.now() +"login:"+u_account+" IP:"+clientIP);
return Result.success("登录成功",token); return Result.success("登录成功",token);
} }
@RequestMapping("/init") @RequestMapping("/init")
Result initUser(@RequestBody User user,@RequestHeader(name="Authorization") String token) { Result initUser(@RequestBody User user,@RequestHeader(name="Authorization") String token) {
//解析token //解析token
Map<String,Object> claim = Jwt.parseToken(token); Map<String,Object> claim = Jwt.parseToken(token);
String u_id = (String) claim.get("u_id"); String u_id = (String) claim.get("u_id");
//初始化用户信息,写入表 //初始化用户信息,写入表
userService.updateName(u_id,user.getU_name()); userService.updateName(u_id,user.getU_name());
userService.updateIntroduction(u_id,user.getU_introduction()); userService.updateIntroduction(u_id,user.getU_introduction());
return Result.success("初始化成功!"); return Result.success("初始化成功!");
} }
} }

122
src/main/java/myplayer/controller/MailCodeController.java
View File

@@ -1,61 +1,61 @@
package myplayer.controller; package myplayer.controller;
import com.github.benmanes.caffeine.cache.Cache; import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.Caffeine;
import myplayer.entity.Account; import myplayer.entity.Account;
import myplayer.entity.Code; import myplayer.entity.Code;
import myplayer.service.CodeManageService; import myplayer.service.CodeManageService;
import myplayer.utils.RandomCode; import myplayer.utils.RandomCode;
import myplayer.utils.Result; import myplayer.utils.Result;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@RestController @RestController
@RequestMapping("/code") @RequestMapping("/code")
public class MailCodeController { public class MailCodeController {
private static final Cache<String,String> waitingList = Caffeine.newBuilder() private static final Cache<String,String> waitingList = Caffeine.newBuilder()
.expireAfterWrite(5, TimeUnit.MINUTES) .expireAfterWrite(5, TimeUnit.MINUTES)
.build(); .build();
@Autowired @Autowired
CodeManageService codeManageService; CodeManageService codeManageService;
@PostMapping("/sendcode") @PostMapping("/sendcode")
Result sendcode(@RequestBody Account account){ Result sendcode(@RequestBody Account account){
if(account.getU_account()==null) return Result.error("邮箱为空"); if(account.getU_account()==null) return Result.error("邮箱为空");
System.out.println(account); System.out.println(account);
String tempId; String tempId;
do{ do{
tempId=RandomCode.generateID(); tempId=RandomCode.generateID();
} }
while(waitingList.getIfPresent(tempId)!=null); while(waitingList.getIfPresent(tempId)!=null);
try { try {
waitingList.put(tempId,codeManageService.sendMail(account.getU_account())); waitingList.put(tempId,codeManageService.sendMail(account.getU_account()));
return Result.success("发送成功！",tempId); return Result.success("发送成功！",tempId);
} catch (Exception e) { } catch (Exception e) {
return Result.serverError("发送失败"); return Result.serverError("发送失败");
} }
} }
@PostMapping("/verifycode") @PostMapping("/verifycode")
Result verifyCode(@RequestBody Code code){ Result verifyCode(@RequestBody Code code){
//测试验证码 //测试验证码
if(code.getCode().equals("666666")) return Result.success("验证成功"); if(code.getCode().equals("666666")) return Result.success("验证成功");
String tempCode=waitingList.getIfPresent(code.getV_id()); String tempCode=waitingList.getIfPresent(code.getV_id());
System.out.println("waitingList"+tempCode+"\nv_id:"+code.getV_id()+"\ncode:"+code.getCode()); System.out.println("waitingList"+tempCode+"\nv_id:"+code.getV_id()+"\ncode:"+code.getCode());
if(tempCode==null) return Result.timeout("验证码已过期"); if(tempCode==null) return Result.timeout("验证码已过期");
if(!tempCode.equals(code.getCode())) return Result.codeError("验证码错误！"); if(!tempCode.equals(code.getCode())) return Result.codeError("验证码错误！");
waitingList.invalidate(code.getV_id()); waitingList.invalidate(code.getV_id());
return Result.success("验证成功"); return Result.success("验证成功");
} }
} }

140
src/main/java/myplayer/controller/PlayroomController.java
View File

@@ -1,70 +1,70 @@
package myplayer.controller; package myplayer.controller;
import myplayer.entity.Own; import myplayer.entity.Own;
import myplayer.entity.Playroom; import myplayer.entity.Playroom;
import myplayer.service.OwnService; import myplayer.service.OwnService;
import myplayer.service.PlayroomService; import myplayer.service.PlayroomService;
import myplayer.utils.Jwt; import myplayer.utils.Jwt;
import myplayer.utils.RandomCode; import myplayer.utils.RandomCode;
import myplayer.utils.Result; import myplayer.utils.Result;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
@RestController @RestController
@RequestMapping("/room") @RequestMapping("/room")
public class PlayroomController { public class PlayroomController {
@Autowired @Autowired
private PlayroomService playroomService; private PlayroomService playroomService;
@Autowired @Autowired
private OwnService ownService; private OwnService ownService;
// 创建房间 // 创建房间
@PostMapping("/create") @PostMapping("/create")
public Result createRoom(@RequestHeader("Authorization") String token, @RequestBody Playroom playroom) { public Result createRoom(@RequestHeader("Authorization") String token, @RequestBody Playroom playroom) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
String r_id; String r_id;
do { do {
r_id = "R" + RandomCode.generateID(); r_id = "R" + RandomCode.generateID();
} while (playroomService.playRoomIsExist(r_id) == 1); } while (playroomService.playRoomIsExist(r_id) == 1);
playroom.setR_id(r_id); playroom.setR_id(r_id);
Own own = new Own(r_id, u_id, 0); Own own = new Own(r_id, u_id, 0);
playroomService.createPlayroom(playroom); playroomService.createPlayroom(playroom);
ownService.createPlayroom(own); ownService.createPlayroom(own);
return Result.success("创建成功"); return Result.success("创建成功");
} }
//搜索房间 //搜索房间
@GetMapping("/search") @GetMapping("/search")
public Result searchPlayroom(@RequestHeader("Authorization") String token,@RequestParam String r_name){ public Result searchPlayroom(@RequestHeader("Authorization") String token,@RequestParam String r_name){
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
return Result.success("查询成功",playroomService.searchPlayroom(u_id,r_name)); return Result.success("查询成功",playroomService.searchPlayroom(u_id,r_name));
} }
//获取已加入列表 //获取已加入列表
@GetMapping("/getrooms") @GetMapping("/getrooms")
public Result getRooms(@RequestHeader("Authorization") String token){ public Result getRooms(@RequestHeader("Authorization") String token){
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
return Result.success("查询成功",playroomService.getRooms(u_id)); return Result.success("查询成功",playroomService.getRooms(u_id));
} }
//获取房间成员 //获取房间成员
@GetMapping("/getmember") @GetMapping("/getmember")
public Result getMembers(@RequestParam String r_id){ public Result getMembers(@RequestParam String r_id){
return Result.success("查询成功",playroomService.getMembers(r_id)); return Result.success("查询成功",playroomService.getMembers(r_id));
} }
//获取对应房间信息 //获取对应房间信息
//修改对应房间信息 //修改对应房间信息
} }

72
src/main/java/myplayer/controller/TestController.java
View File

@@ -1,36 +1,36 @@
package myplayer.controller; package myplayer.controller;
import myplayer.service.CodeManageService; import myplayer.service.CodeManageService;
import myplayer.utils.Result; import myplayer.utils.Result;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
@RestController @RestController
@RequestMapping("/test") @RequestMapping("/test")
public class TestController { public class TestController {
@Autowired @Autowired
private CodeManageService codeManageService; private CodeManageService codeManageService;
private Map<Integer, String> codeMap = new HashMap<>(); private Map<Integer, String> codeMap = new HashMap<>();
@GetMapping("/hello") @GetMapping("/hello")
public Result hello(){ public Result hello(){
return Result.success("hello"); return Result.success("hello");
} }
@PostMapping("/send") @PostMapping("/send")
public Result send(){ public Result send(){
codeMap.put(1,codeManageService.sendMail("xyf17818039334@163.com")); codeMap.put(1,codeManageService.sendMail("xyf17818039334@163.com"));
return Result.success("1"); return Result.success("1");
} }
@PostMapping("/verifycode") @PostMapping("/verifycode")
public Result verifycode(@RequestBody myplayer.entity.test.Test test){ public Result verifycode(@RequestBody myplayer.entity.test.Test test){
if(codeMap.get(1).equals(test.getCode())) if(codeMap.get(1).equals(test.getCode()))
return Result.success("1"); return Result.success("1");
return Result.error("X"); return Result.error("X");
} }
} }

172
src/main/java/myplayer/controller/UserController.java
View File

@@ -1,86 +1,86 @@
package myplayer.controller; package myplayer.controller;
import myplayer.entity.Account; import myplayer.entity.Account;
import myplayer.entity.User; import myplayer.entity.User;
import myplayer.mapper.AccountMapper; import myplayer.mapper.AccountMapper;
import myplayer.service.AccountService; import myplayer.service.AccountService;
import myplayer.service.UserService; import myplayer.service.UserService;
import myplayer.utils.Jwt; import myplayer.utils.Jwt;
import myplayer.utils.Md5; import myplayer.utils.Md5;
import myplayer.utils.Result; import myplayer.utils.Result;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
@RestController @RestController
@RequestMapping("/user") @RequestMapping("/user")
public class UserController { public class UserController {
@Autowired @Autowired
private UserService userService; private UserService userService;
@Autowired @Autowired
private AccountService accountService; private AccountService accountService;
@Autowired @Autowired
private AccountMapper accountMapper; private AccountMapper accountMapper;
@GetMapping("/getuserinfo") @GetMapping("/getuserinfo")
Result getUserInfo(@RequestHeader(name = "Authorization") String token) { Result getUserInfo(@RequestHeader(name = "Authorization") String token) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
User user; User user;
try { try {
user = userService.getUserInfo(u_id); user = userService.getUserInfo(u_id);
} catch (Exception e) { } catch (Exception e) {
return Result.error("获取用户信息失败"); return Result.error("获取用户信息失败");
} }
if (user == null) { if (user == null) {
return Result.error("获取用户信息失败，用户不存在"); return Result.error("获取用户信息失败，用户不存在");
} }
System.out.println("获取用户信息：" + u_id); System.out.println("获取用户信息：" + u_id);
return Result.success("获取用户信息成功", user); return Result.success("获取用户信息成功", user);
} }
@PostMapping("/updatename") @PostMapping("/updatename")
Result updateName(@RequestHeader(name = "Authorization") String token, @RequestBody User user) { Result updateName(@RequestHeader(name = "Authorization") String token, @RequestBody User user) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
try { try {
userService.updateName(u_id, user.getU_name()); userService.updateName(u_id, user.getU_name());
} catch (Exception e) { } catch (Exception e) {
return Result.error("修改用户名失败"); return Result.error("修改用户名失败");
} }
System.out.println("用户名修改：" + u_id); System.out.println("用户名修改：" + u_id);
return Result.success("修改用户名成功"); return Result.success("修改用户名成功");
} }
@PostMapping("/updateintroduction") @PostMapping("/updateintroduction")
Result updateIntroduction(@RequestHeader(name = "Authorization") String token, @RequestBody User user) { Result updateIntroduction(@RequestHeader(name = "Authorization") String token, @RequestBody User user) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
userService.updateIntroduction(u_id, user.getU_introduction()); userService.updateIntroduction(u_id, user.getU_introduction());
return Result.success("修改用户简介成功"); return Result.success("修改用户简介成功");
} }
@PostMapping("/updateaccount") @PostMapping("/updateaccount")
Result updateAccount(@RequestHeader(name = "Authorization") String token, @RequestBody Account account) { Result updateAccount(@RequestHeader(name = "Authorization") String token, @RequestBody Account account) {
String u_id = Jwt.getU_id(token); String u_id = Jwt.getU_id(token);
accountService.updateAccount(u_id, account.getU_account()); accountService.updateAccount(u_id, account.getU_account());
return Result.success("修改用户账号成功"); return Result.success("修改用户账号成功");
} }
@PostMapping("/updatepassword") @PostMapping("/updatepassword")
Result updatePassword(@RequestHeader(name = "Authorization") String token, String oldpassword, String password) { Result updatePassword(@RequestHeader(name = "Authorization") String token, String oldpassword, String password) {
String account = Jwt.getAccount(token); String account = Jwt.getAccount(token);
System.out.println(account); System.out.println(account);
if (!Md5.checkPassword(oldpassword,accountService.verifyPassword(account))) { if (!Md5.checkPassword(oldpassword,accountService.verifyPassword(account))) {
System.out.println(Md5.checkPassword(oldpassword,accountService.verifyPassword(account))); System.out.println(Md5.checkPassword(oldpassword,accountService.verifyPassword(account)));
return Result.error("修改用户密码失败，原密码错误"); return Result.error("修改用户密码失败，原密码错误");
} }
accountService.updatePassword(account, Md5.getMD5String(password)); accountService.updatePassword(account, Md5.getMD5String(password));
return Result.success("修改用户密码成功"); return Result.success("修改用户密码成功");
} }
} }

38
src/main/java/myplayer/entity/Account.java
View File

@@ -1,19 +1,19 @@
package myplayer.entity; package myplayer.entity;
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data; import lombok.Data;
@Data @Data
@TableName("account") @TableName("account")
public class Account { public class Account {
@TableId("u_id") @TableId("u_id")
private String u_id; private String u_id;
private String u_account; private String u_account;
private String u_password; private String u_password;
private String ip; private String ip;
} }

18
src/main/java/myplayer/entity/Code.java
View File

@@ -1,9 +1,9 @@
package myplayer.entity; package myplayer.entity;
import lombok.Data; import lombok.Data;
@Data @Data
public class Code { public class Code {
private String v_id; private String v_id;
private String code; private String code;
} }

42
src/main/java/myplayer/entity/Friend.java
View File

@@ -1,21 +1,21 @@
package myplayer.entity; package myplayer.entity;
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data; import lombok.Data;
@Data @Data
@TableName("friends") @TableName("friends")
public class Friend { public class Friend {
@TableId("u_id") @TableId("u_id")
private String u_id; private String u_id;
private String f_id; private String f_id;
public Friend(String u_id, String f_id) { public Friend(String u_id, String f_id) {
this.u_id = u_id; this.u_id = u_id;
this.f_id = f_id; this.f_id = f_id;
} }
} }

38
src/main/java/myplayer/entity/Groupchat.java
View File

@@ -1,19 +1,19 @@
package myplayer.entity; package myplayer.entity;
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data; import lombok.Data;
@Data @Data
@TableName("groupchat") @TableName("groupchat")
public class Groupchat { public class Groupchat {
@TableId("g_id") @TableId("g_id")
private String g_id; private String g_id;
private String g_name; private String g_name;
private String g_avatar; private String g_avatar;
private String g_note; private String g_note;
private Integer identify; private Integer identify;
} }

44
src/main/java/myplayer/entity/Grouprelation.java
View File

@@ -1,22 +1,22 @@
package myplayer.entity; package myplayer.entity;
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data; import lombok.Data;
@Data @Data
@TableName("grouprelation") @TableName("grouprelation")
public class Grouprelation { public class Grouprelation {
@TableId("g_id") @TableId("g_id")
private String g_id; private String g_id;
private String u_id; private String u_id;
private Integer role; private Integer role;
public Grouprelation(String g_id, String u_id, Integer role) { public Grouprelation(String g_id, String u_id, Integer role) {
this.g_id = g_id; this.g_id = g_id;
this.u_id = u_id; this.u_id = u_id;
this.role = role; this.role = role;
} }
} }

42
src/main/java/myplayer/entity/Inviting.java
View File

@@ -1,21 +1,21 @@
package myplayer.entity; package myplayer.entity;
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data; import lombok.Data;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@Data @Data
@TableName("inviting") @TableName("inviting")
public class Inviting { public class Inviting {
private int inviting_id; private int inviting_id;
@TableId("inviter") @TableId("inviter")
private String inviter; private String inviter;
private String target; private String target;
private String room; private String room;
private LocalDateTime time; private LocalDateTime time;
private int status; private int status;
} }

42
src/main/java/myplayer/entity/Own.java
View File

@@ -1,21 +1,21 @@
package myplayer.entity; package myplayer.entity;
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data; import lombok.Data;
@Data @Data
@TableName("own") @TableName("own")
public class Own { public class Own {
@TableId("r_id") @TableId("r_id")
private String r_id; private String r_id;
private String u_id; private String u_id;
private Integer role; //0:owner 1:manager 2:member private Integer role; //0:owner 1:manager 2:member
public Own(String r_id, String u_id, Integer role) { public Own(String r_id, String u_id, Integer role) {
this.r_id = r_id; this.r_id = r_id;
this.u_id = u_id; this.u_id = u_id;
this.role = role; this.role = role;
} }
} }

34
src/main/java/myplayer/entity/Playroom.java
View File

@@ -1,17 +1,17 @@
package myplayer.entity; package myplayer.entity;
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data; import lombok.Data;
@Data @Data
@TableName("playrooms") @TableName("playrooms")
public class Playroom { public class Playroom {
@TableId("r_id") @TableId("r_id")
private String r_id; private String r_id;
private String r_name;//房间名 private String r_name;//房间名
private String r_avatar; private String r_avatar;
private String r_introduction; private String r_introduction;
} }

40
src/main/java/myplayer/entity/User.java
View File

@@ -1,20 +1,20 @@
package myplayer.entity; package myplayer.entity;
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data; import lombok.Data;
@Data @Data
@TableName("user") @TableName("user")
public class User { public class User {
@TableId("u_id") @TableId("u_id")
private String u_id; private String u_id;
private String u_name; private String u_name;
private String u_introduction; private String u_introduction;
private String u_avatar; private String u_avatar;
} }

46
src/main/java/myplayer/entity/request/InvitingDetails.java
View File

@@ -1,23 +1,23 @@
package myplayer.entity.request; package myplayer.entity.request;
import lombok.Data; import lombok.Data;
import myplayer.entity.Inviting; import myplayer.entity.Inviting;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@Data @Data
public class InvitingDetails { public class InvitingDetails {
private String inviter_name; private String inviter_name;
private String inviter_avatar; private String inviter_avatar;
private String inviter; private String inviter;
private String room; private String room;
private LocalDateTime time; private LocalDateTime time;
public InvitingDetails(Inviting inviting,String inviter_name, String inviter_avatar) { public InvitingDetails(Inviting inviting,String inviter_name, String inviter_avatar) {
this.inviter_name = inviter_name; this.inviter_name = inviter_name;
this.inviter_avatar = inviter_avatar; this.inviter_avatar = inviter_avatar;
this.inviter = inviting.getInviter(); this.inviter = inviting.getInviter();
this.room = inviting.getRoom(); this.room = inviting.getRoom();
this.time = inviting.getTime(); this.time = inviting.getTime();
} }
} }

56
src/main/java/myplayer/entity/request/Member.java
View File

@@ -1,28 +1,28 @@
package myplayer.entity.request; package myplayer.entity.request;
import lombok.Data; import lombok.Data;
import myplayer.entity.User; import myplayer.entity.User;
@Data @Data
public class Member { public class Member {
private String m_id; private String m_id;
private String m_name; private String m_name;
private String m_avatar; private String m_avatar;
private String m_introduction; private String m_introduction;
private Integer role; private Integer role;
public Member(User user, Integer role) { public Member(User user, Integer role) {
this.m_id = user.getU_id(); this.m_id = user.getU_id();
this.m_name = user.getU_name(); this.m_name = user.getU_name();
this.m_avatar = user.getU_avatar(); this.m_avatar = user.getU_avatar();
this.m_introduction = user.getU_introduction(); this.m_introduction = user.getU_introduction();
this.role = role; this.role = role;
} }
} }

24
src/main/java/myplayer/entity/request/PlayroomDetails.java
View File

@@ -1,12 +1,12 @@
package myplayer.entity.request; package myplayer.entity.request;
import lombok.Data; import lombok.Data;
@Data @Data
public class PlayroomDetails{ public class PlayroomDetails{
private String r_id; private String r_id;
private String r_name;//房间名 private String r_name;//房间名
private String r_avatar; private String r_avatar;
private String r_introduction; private String r_introduction;
private Integer role; private Integer role;
} }

20
src/main/java/myplayer/entity/test/Test.java
View File

@@ -1,10 +1,10 @@
package myplayer.entity.test; package myplayer.entity.test;
import lombok.Data; import lombok.Data;
@Data @Data
public class Test { public class Test {
private String code; private String code;
} }

62
src/main/java/myplayer/mapper/AccountMapper.java
View File

@@ -1,31 +1,31 @@
package myplayer.mapper; package myplayer.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import myplayer.entity.Account; import myplayer.entity.Account;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update; import org.apache.ibatis.annotations.Update;
@Mapper @Mapper
public interface AccountMapper extends BaseMapper<Account> { public interface AccountMapper extends BaseMapper<Account> {
@Select("select count(*) from account where u_account=#{u_account}") @Select("select count(*) from account where u_account=#{u_account}")
int isExist(@Param("u_account") String u_account); int isExist(@Param("u_account") String u_account);
@Select("select account.u_password from account where u_account=#{u_account}") @Select("select account.u_password from account where u_account=#{u_account}")
String verifyPassword(String u_account); String verifyPassword(String u_account);
@Select("select account.u_id from account where u_account = #{u_account}") @Select("select account.u_id from account where u_account = #{u_account}")
String getUId(@Param("u_account") String u_account); String getUId(@Param("u_account") String u_account);
@Update("update account set u_account=#{u_account} where u_id=#{u_id}") @Update("update account set u_account=#{u_account} where u_id=#{u_id}")
void updateAccount(@Param("u_id") String u_id,@Param("u_account") String u_account); void updateAccount(@Param("u_id") String u_id,@Param("u_account") String u_account);
@Update("update account set u_password=#{u_password} where u_account=#{u_account}") @Update("update account set u_password=#{u_password} where u_account=#{u_account}")
void updatePassword(@Param("u_account") String u_account,@Param("u_password") String u_password); void updatePassword(@Param("u_account") String u_account,@Param("u_password") String u_password);
@Update("update account set ip=#{clientIP} where u_id=#{u_id}") @Update("update account set ip=#{clientIP} where u_id=#{u_id}")
void updateIp(@Param("u_id") String u_id,@Param("clientIP") String clientIP); void updateIp(@Param("u_id") String u_id,@Param("clientIP") String clientIP);
} }

26
src/main/java/myplayer/mapper/FriendMapper.java
View File

@@ -1,13 +1,13 @@
package myplayer.mapper; package myplayer.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import myplayer.entity.Friend; import myplayer.entity.Friend;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
@Mapper @Mapper
public interface FriendMapper extends BaseMapper<Friend> { public interface FriendMapper extends BaseMapper<Friend> {
} }

44
src/main/java/myplayer/mapper/GroupMapper.java
View File

@@ -1,22 +1,22 @@
package myplayer.mapper; package myplayer.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import myplayer.entity.Groupchat; import myplayer.entity.Groupchat;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update; import org.apache.ibatis.annotations.Update;
@Mapper @Mapper
public interface GroupMapper extends BaseMapper<Groupchat> { public interface GroupMapper extends BaseMapper<Groupchat> {
@Select("select count(*) from groupchat where g_id = #{g_id}") @Select("select count(*) from groupchat where g_id = #{g_id}")
public int groupIsExist(@Param("g_id")String g_id); public int groupIsExist(@Param("g_id")String g_id);
@Update("update groupchat set g_note = #{g_note} where g_id = #{g_id}") @Update("update groupchat set g_note = #{g_note} where g_id = #{g_id}")
void setNote(@Param("g_id")String g_id, @Param("g_note") String g_note); void setNote(@Param("g_id")String g_id, @Param("g_note") String g_note);
@Update("update groupchat set g_name = #{g_name} where g_id = #{g_id}") @Update("update groupchat set g_name = #{g_name} where g_id = #{g_id}")
void setName(@Param("g_id") String gId,@Param("g_name") String gName); void setName(@Param("g_id") String gId,@Param("g_name") String gName);
} }

36
src/main/java/myplayer/mapper/GrouprelationMapper.java
View File

@@ -1,18 +1,18 @@
package myplayer.mapper; package myplayer.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import myplayer.entity.Grouprelation; import myplayer.entity.Grouprelation;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select;
@Mapper @Mapper
public interface GrouprelationMapper extends BaseMapper<Grouprelation> { public interface GrouprelationMapper extends BaseMapper<Grouprelation> {
@Select("select role from grouprelation where g_id=#{g_id} and u_id=#{u_id}") @Select("select role from grouprelation where g_id=#{g_id} and u_id=#{u_id}")
public Integer getRole(@Param("u_id")String u_id, @Param("g_id")String g_id); public Integer getRole(@Param("u_id")String u_id, @Param("g_id")String g_id);
} }

22
src/main/java/myplayer/mapper/InvitingMapper.java
View File

@@ -1,11 +1,11 @@
package myplayer.mapper; package myplayer.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import myplayer.entity.Inviting; import myplayer.entity.Inviting;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
@Mapper @Mapper
public interface InvitingMapper extends BaseMapper<Inviting> { public interface InvitingMapper extends BaseMapper<Inviting> {
} }

18
src/main/java/myplayer/mapper/OwnMapper.java
View File

@@ -1,9 +1,9 @@
package myplayer.mapper; package myplayer.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import myplayer.entity.Own; import myplayer.entity.Own;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
@Mapper @Mapper
public interface OwnMapper extends BaseMapper<Own> { public interface OwnMapper extends BaseMapper<Own> {
} }

28
src/main/java/myplayer/mapper/PlayroomMapper.java
View File

@@ -1,14 +1,14 @@
package myplayer.mapper; package myplayer.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import myplayer.entity.Playroom; import myplayer.entity.Playroom;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select;
@Mapper @Mapper
public interface PlayroomMapper extends BaseMapper<Playroom> { public interface PlayroomMapper extends BaseMapper<Playroom> {
@Select("select count(*) from playrooms where r_id=#{r_id}") @Select("select count(*) from playrooms where r_id=#{r_id}")
public int playeroomIsExist(@Param("r_id") String r_id); public int playeroomIsExist(@Param("r_id") String r_id);
} }

48
src/main/java/myplayer/mapper/UserMapper.java
View File

@@ -1,24 +1,24 @@
package myplayer.mapper; package myplayer.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import myplayer.entity.User; import myplayer.entity.User;
import org.apache.ibatis.annotations.*; import org.apache.ibatis.annotations.*;
@Mapper @Mapper
public interface UserMapper extends BaseMapper<User> { public interface UserMapper extends BaseMapper<User> {
@Insert("insert into user(u_id) values (#{u_id})") @Insert("insert into user(u_id) values (#{u_id})")
void initUser(@Param("u_id") String u_id); void initUser(@Param("u_id") String u_id);
@Select("select u_avatar from user where u_id = #{u_id}") @Select("select u_avatar from user where u_id = #{u_id}")
String getUserAvatar(@Param("u_id") String u_id); String getUserAvatar(@Param("u_id") String u_id);
@Update("update user set u_avatar = #{u_avatar} where u_id=#{u_id}") @Update("update user set u_avatar = #{u_avatar} where u_id=#{u_id}")
int updateAvatar(@Param("u_id") String u_id, @Param("u_avatar") String u_avatar); int updateAvatar(@Param("u_id") String u_id, @Param("u_avatar") String u_avatar);
@Update("update user set u_name=#{u_name} where u_id=#{u_id}") @Update("update user set u_name=#{u_name} where u_id=#{u_id}")
void updateName(@Param("u_id") String u_id,@Param("u_name") String u_name); void updateName(@Param("u_id") String u_id,@Param("u_name") String u_name);
@Update("update user set u_introduction=#{u_introduction} where u_id=#{u_id}") @Update("update user set u_introduction=#{u_introduction} where u_id=#{u_id}")
void updateIntroduction(@Param("u_id") String u_id,@Param("u_introduction") String u_introduction); void updateIntroduction(@Param("u_id") String u_id,@Param("u_introduction") String u_introduction);
} }

98
src/main/java/myplayer/service/AccountService.java
View File

@@ -1,49 +1,49 @@
package myplayer.service; package myplayer.service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import myplayer.entity.Account; import myplayer.entity.Account;
import myplayer.mapper.AccountMapper; import myplayer.mapper.AccountMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@Service @Service
public class AccountService { public class AccountService {
@Autowired @Autowired
private AccountMapper accountMapper; private AccountMapper accountMapper;
public void updateAccount(String uId, String uAccount) { public void updateAccount(String uId, String uAccount) {
accountMapper.updateAccount(uId, uAccount); accountMapper.updateAccount(uId, uAccount);
} }
public void updatePassword(String account, String password) { public void updatePassword(String account, String password) {
accountMapper.updatePassword(account, password); accountMapper.updatePassword(account, password);
} }
public String verifyPassword(String account) { public String verifyPassword(String account) {
return accountMapper.verifyPassword(account); return accountMapper.verifyPassword(account);
} }
public int isExist(String uAccount) { public int isExist(String uAccount) {
return accountMapper.isExist(uAccount); return accountMapper.isExist(uAccount);
} }
public void insert(Account account) { public void insert(Account account) {
accountMapper.insert(account); accountMapper.insert(account);
} }
public String getUId(String uAccount) { public String getUId(String uAccount) {
return accountMapper.getUId(uAccount); return accountMapper.getUId(uAccount);
} }
public Boolean idIsExist(String uId) { public Boolean idIsExist(String uId) {
QueryWrapper<Account> queryWrapper = new QueryWrapper<>(); QueryWrapper<Account> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("u_id", uId); queryWrapper.eq("u_id", uId);
//找到了返回true,没找到返回false //找到了返回true,没找到返回false
return accountMapper.selectCount(queryWrapper) != 0; return accountMapper.selectCount(queryWrapper) != 0;
} }
public void updateIP(String u_id,String clientIP){ public void updateIP(String u_id,String clientIP){
accountMapper.updateIp(u_id,clientIP); accountMapper.updateIp(u_id,clientIP);
} }
} }

102
src/main/java/myplayer/service/AvatarService.java
View File

@@ -1,52 +1,52 @@
package myplayer.service; package myplayer.service;
import myplayer.mapper.UserMapper; import myplayer.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.nio.file.Paths; import java.nio.file.Paths;
import java.nio.file.StandardCopyOption; import java.nio.file.StandardCopyOption;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
@Service @Service
public class AvatarService { public class AvatarService {
@Autowired @Autowired
private UserMapper userMapper; private UserMapper userMapper;
@Value("${file.avatar-dir}") @Value("${file.avatar-dir}")
private String avatarDir; private String avatarDir;
// 允许的文件类型 // 允许的文件类型
private static final List<String> ALLOWED_EXTENSIONS = Arrays.asList(".jpg", ".jpeg", ".png", ".gif"); private static final List<String> ALLOWED_EXTENSIONS = Arrays.asList(".jpg", ".jpeg", ".png", ".gif");
public String storeAvatar(MultipartFile file, String Id) throws IOException { public String storeAvatar(MultipartFile file, String Id) throws IOException {
File dir = new File(avatarDir); File dir = new File(avatarDir);
if (!dir.exists()) dir.mkdirs(); if (!dir.exists()) dir.mkdirs();
// 取文件扩展名并检查是否合法 // 取文件扩展名并检查是否合法
String originalFileName = file.getOriginalFilename(); String originalFileName = file.getOriginalFilename();
String fileExtension = ""; String fileExtension = "";
if (originalFileName != null && originalFileName.contains(".")) { if (originalFileName != null && originalFileName.contains(".")) {
fileExtension = originalFileName.substring(originalFileName.lastIndexOf(".")).toLowerCase(); fileExtension = originalFileName.substring(originalFileName.lastIndexOf(".")).toLowerCase();
} }
if (!ALLOWED_EXTENSIONS.contains(fileExtension)) { if (!ALLOWED_EXTENSIONS.contains(fileExtension)) {
throw new IOException("仅支持 JPG, PNG, GIF 格式"); throw new IOException("仅支持 JPG, PNG, GIF 格式");
} }
// 以 UID 命名文件 // 以 UID 命名文件
String fileName = Id + fileExtension; String fileName = Id + fileExtension;
Path targetPath = Paths.get(avatarDir, fileName); Path targetPath = Paths.get(avatarDir, fileName);
Files.copy(file.getInputStream(), targetPath, StandardCopyOption.REPLACE_EXISTING); Files.copy(file.getInputStream(), targetPath, StandardCopyOption.REPLACE_EXISTING);
userMapper.updateAvatar(Id, "https://www.merlin.xin/avatars/" + fileName); userMapper.updateAvatar(Id, "https://www.merlin.xin/avatars/" + fileName);
return "/avatars/" + fileName; // 返回访问 URL return "/avatars/" + fileName; // 返回访问 URL
} }
} }

58
src/main/java/myplayer/service/CodeManageService.java
View File

@@ -1,29 +1,29 @@
package myplayer.service; package myplayer.service;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.mail.SimpleMailMessage; import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender; import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@Service @Service
public class CodeManageService { public class CodeManageService {
@Autowired @Autowired
JavaMailSender mailSender; JavaMailSender mailSender;
@Value("${spring.mail.username}") @Value("${spring.mail.username}")
private String sender; private String sender;
public String sendMail(String receiver){ public String sendMail(String receiver){
String code = Double.toString(Math.random()).substring(2,8); String code = Double.toString(Math.random()).substring(2,8);
SimpleMailMessage message = new SimpleMailMessage(); SimpleMailMessage message = new SimpleMailMessage();
message.setFrom(sender); message.setFrom(sender);
message.setTo(receiver); message.setTo(receiver);
message.setSubject("MyPlayer"); message.setSubject("MyPlayer");
message.setText("欢迎使用MyPlayer！\n"+"您的验证码为："+code+"\n验证码请勿泄露！"); message.setText("欢迎使用MyPlayer！\n"+"您的验证码为："+code+"\n验证码请勿泄露！");
mailSender.send(message); mailSender.send(message);
return code; return code;
} }
} }

124
src/main/java/myplayer/service/FriendService.java
View File

@@ -1,62 +1,62 @@
package myplayer.service; package myplayer.service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import myplayer.entity.Friend; import myplayer.entity.Friend;
import myplayer.entity.User; import myplayer.entity.User;
import myplayer.mapper.FriendMapper; import myplayer.mapper.FriendMapper;
import myplayer.mapper.UserMapper; import myplayer.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
@Service @Service
public class FriendService { public class FriendService {
private final String DB = "myplayer:"; private final String DB = "myplayer:";
@Autowired @Autowired
private StringRedisTemplate stringRedisTemplate; private StringRedisTemplate stringRedisTemplate;
@Autowired @Autowired
private FriendMapper friendMapper; private FriendMapper friendMapper;
@Autowired @Autowired
private UserMapper userMapper; private UserMapper userMapper;
//添加好友 //添加好友
public void addFriend(String userId, String friendId) { public void addFriend(String userId, String friendId) {
stringRedisTemplate.opsForSet().add(DB+"user:"+userId+":friends", friendId); stringRedisTemplate.opsForSet().add(DB+"user:"+userId+":friends", friendId);
stringRedisTemplate.opsForSet().add(DB+"user:"+friendId+":friends", userId); stringRedisTemplate.opsForSet().add(DB+"user:"+friendId+":friends", userId);
System.out.println("redis saved"); System.out.println("redis saved");
friendMapper.insert(new Friend(userId, friendId)); friendMapper.insert(new Friend(userId, friendId));
friendMapper.insert(new Friend(friendId, userId)); friendMapper.insert(new Friend(friendId, userId));
} }
//删除好友 //删除好友
public void removeFriend(String userId, String friendId) { public void removeFriend(String userId, String friendId) {
stringRedisTemplate.opsForSet().remove(DB+"user:"+userId+":friends", friendId); stringRedisTemplate.opsForSet().remove(DB+"user:"+userId+":friends", friendId);
stringRedisTemplate.opsForSet().remove(DB+"user:"+friendId+":friends", userId); stringRedisTemplate.opsForSet().remove(DB+"user:"+friendId+":friends", userId);
System.out.println("redis removed"); System.out.println("redis removed");
friendMapper.deleteById(new Friend(userId, friendId)); friendMapper.deleteById(new Friend(userId, friendId));
friendMapper.deleteById(new Friend(friendId, userId)); friendMapper.deleteById(new Friend(friendId, userId));
} }
//获取好友列表 //获取好友列表
public List<User> getFriends(String userId) { public List<User> getFriends(String userId) {
Set<String> f_ids = stringRedisTemplate.opsForSet().members(DB+"user:"+userId+":friends"); Set<String> f_ids = stringRedisTemplate.opsForSet().members(DB+"user:"+userId+":friends");
if (f_ids != null && f_ids.isEmpty()) { if (f_ids != null && f_ids.isEmpty()) {
System.out.println("无好友"); System.out.println("无好友");
return null; return null;
} }
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.in("u_id", f_ids); queryWrapper.in("u_id", f_ids);
return userMapper.selectList(queryWrapper); return userMapper.selectList(queryWrapper);
} }
} }

310
src/main/java/myplayer/service/GroupService.java
View File

@@ -1,155 +1,155 @@
package myplayer.service; package myplayer.service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import myplayer.entity.Groupchat; import myplayer.entity.Groupchat;
import myplayer.entity.Grouprelation; import myplayer.entity.Grouprelation;
import myplayer.entity.User; import myplayer.entity.User;
import myplayer.entity.request.Member; import myplayer.entity.request.Member;
import myplayer.mapper.GroupMapper; import myplayer.mapper.GroupMapper;
import myplayer.mapper.GrouprelationMapper; import myplayer.mapper.GrouprelationMapper;
import myplayer.mapper.UserMapper; import myplayer.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@Service @Service
public class GroupService { public class GroupService {
private final String DB = "myplayer:"; private final String DB = "myplayer:";
@Autowired @Autowired
private GroupMapper groupMapper; private GroupMapper groupMapper;
@Autowired @Autowired
private GrouprelationMapper grouprelationMapper; private GrouprelationMapper grouprelationMapper;
@Autowired @Autowired
private StringRedisTemplate stringRedisTemplate; private StringRedisTemplate stringRedisTemplate;
@Autowired @Autowired
private UserMapper userMapper; private UserMapper userMapper;
public int groupIsExist(String gId) { public int groupIsExist(String gId) {
return groupMapper.groupIsExist(gId); return groupMapper.groupIsExist(gId);
} }
@Transactional @Transactional
public void createGroup(Groupchat groupchat, String uId) { public void createGroup(Groupchat groupchat, String uId) {
groupMapper.insert(groupchat); groupMapper.insert(groupchat);
grouprelationMapper.insert(new Grouprelation(groupchat.getG_id(), uId, 0)); grouprelationMapper.insert(new Grouprelation(groupchat.getG_id(), uId, 0));
stringRedisTemplate.opsForSet().add(DB+groupchat.getG_id(), uId); stringRedisTemplate.opsForSet().add(DB+groupchat.getG_id(), uId);
} }
public List<Groupchat> searchGroups(String uId, String gName) { public List<Groupchat> searchGroups(String uId, String gName) {
QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>(); QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>();
qw1.select("g_id") qw1.select("g_id")
.eq("u_id", uId); .eq("u_id", uId);
List<String> allreadyin = grouprelationMapper.selectObjs(qw1); List<String> allreadyin = grouprelationMapper.selectObjs(qw1);
QueryWrapper<Groupchat> qw2 = new QueryWrapper<>(); QueryWrapper<Groupchat> qw2 = new QueryWrapper<>();
if (!allreadyin.isEmpty()) { if (!allreadyin.isEmpty()) {
qw2.notIn("g_id", allreadyin) qw2.notIn("g_id", allreadyin)
.like("g_name", gName) .like("g_name", gName)
.last("limit 5"); .last("limit 5");
} else { } else {
System.out.println("无已加入群聊，无需排除"); System.out.println("无已加入群聊，无需排除");
qw2.like("g_name", gName) qw2.like("g_name", gName)
.last("limit 5"); .last("limit 5");
} }
return groupMapper.selectList(qw2); return groupMapper.selectList(qw2);
} }
@Transactional @Transactional
public void joinGroup(String uId, String gId) { public void joinGroup(String uId, String gId) {
grouprelationMapper.insert(new Grouprelation(gId, uId, 2)); grouprelationMapper.insert(new Grouprelation(gId, uId, 2));
stringRedisTemplate.opsForSet().add(DB+gId, uId); stringRedisTemplate.opsForSet().add(DB+gId, uId);
} }
public List<Groupchat> getGroups(String uId) { public List<Groupchat> getGroups(String uId) {
QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>(); QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>();
qw1.select("g_id").eq("u_id", uId); qw1.select("g_id").eq("u_id", uId);
List<String> allreadyin = grouprelationMapper.selectObjs(qw1); List<String> allreadyin = grouprelationMapper.selectObjs(qw1);
QueryWrapper<Groupchat> qw2 = new QueryWrapper<>(); QueryWrapper<Groupchat> qw2 = new QueryWrapper<>();
if (!allreadyin.isEmpty()) { if (!allreadyin.isEmpty()) {
qw2.in("g_id", allreadyin); qw2.in("g_id", allreadyin);
return groupMapper.selectList(qw2); return groupMapper.selectList(qw2);
} else { } else {
System.out.println(LocalDateTime.now() + " 无已加入群聊，返回null"); System.out.println(LocalDateTime.now() + " 无已加入群聊，返回null");
return null; return null;
} }
} }
@Transactional @Transactional
public void leave(String uId, String gId) { public void leave(String uId, String gId) {
QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>(); QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>();
qw1.eq("g_id", gId).eq("u_id", uId); qw1.eq("g_id", gId).eq("u_id", uId);
grouprelationMapper.delete(qw1); grouprelationMapper.delete(qw1);
stringRedisTemplate.opsForSet().remove(DB+gId, uId); stringRedisTemplate.opsForSet().remove(DB+gId, uId);
} }
public boolean setNote(String uId, Groupchat groupchat) { public boolean setNote(String uId, Groupchat groupchat) {
//判断权限 //判断权限
Integer role = grouprelationMapper.getRole(uId, groupchat.getG_id()); Integer role = grouprelationMapper.getRole(uId, groupchat.getG_id());
if (role != 0 && role != 1) return false; if (role != 0 && role != 1) return false;
if (groupchat.getG_note() == null) groupMapper.setNote(groupchat.getG_id(), null); if (groupchat.getG_note() == null) groupMapper.setNote(groupchat.getG_id(), null);
groupMapper.setNote(groupchat.getG_id(), groupchat.getG_note()); groupMapper.setNote(groupchat.getG_id(), groupchat.getG_note());
return true; return true;
} }
public void setName(String g_id, String g_name) { public void setName(String g_id, String g_name) {
groupMapper.setName(g_id, g_name); groupMapper.setName(g_id, g_name);
} }
public List<Member> getMembers(String gId) { public List<Member> getMembers(String gId) {
QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>(); QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>();
qw1.eq("g_id", gId); qw1.eq("g_id", gId);
List<Grouprelation> grouprelations = grouprelationMapper.selectList(qw1); List<Grouprelation> grouprelations = grouprelationMapper.selectList(qw1);
Map<String, Integer> roles = new HashMap<>(); Map<String, Integer> roles = new HashMap<>();
List<String> ids = new ArrayList<>(); List<String> ids = new ArrayList<>();
for (Grouprelation g : grouprelations) { for (Grouprelation g : grouprelations) {
roles.put(g.getU_id(), g.getRole()); roles.put(g.getU_id(), g.getRole());
ids.add(g.getU_id()); ids.add(g.getU_id());
} }
QueryWrapper<User> qw2 = new QueryWrapper<>(); QueryWrapper<User> qw2 = new QueryWrapper<>();
qw2.in("u_id", ids); qw2.in("u_id", ids);
List<User> users = userMapper.selectList(qw2); List<User> users = userMapper.selectList(qw2);
List<Member> members = new ArrayList<>(); List<Member> members = new ArrayList<>();
for (User u : users) { for (User u : users) {
members.add(new Member(u, roles.get(u.getU_id()))); members.add(new Member(u, roles.get(u.getU_id())));
} }
return members; return members;
} }
public boolean setRole(String uId, Grouprelation grouprelation) { public boolean setRole(String uId, Grouprelation grouprelation) {
//判断权限 //判断权限
Integer role = grouprelationMapper.getRole(uId, grouprelation.getG_id()); Integer role = grouprelationMapper.getRole(uId, grouprelation.getG_id());
if (role != 0) return false; if (role != 0) return false;
//判断数量 //判断数量
if(grouprelation.getRole()==1){ if(grouprelation.getRole()==1){
QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>(); QueryWrapper<Grouprelation> qw1 = new QueryWrapper<>();
qw1.eq("g_id", grouprelation.getG_id()) qw1.eq("g_id", grouprelation.getG_id())
.eq("role",1); .eq("role",1);
if(grouprelationMapper.selectCount(qw1)>=4) return false; if(grouprelationMapper.selectCount(qw1)>=4) return false;
} }
grouprelationMapper.update(grouprelation, new UpdateWrapper<Grouprelation>() grouprelationMapper.update(grouprelation, new UpdateWrapper<Grouprelation>()
.eq("g_id",grouprelation.getG_id()) .eq("g_id",grouprelation.getG_id())
.eq("u_id",grouprelation.getU_id())); .eq("u_id",grouprelation.getU_id()));
return true; return true;
} }
public int verifyRole(String uId, String gId) { public int verifyRole(String uId, String gId) {
return grouprelationMapper.getRole(uId, gId); return grouprelationMapper.getRole(uId, gId);
} }
} }

284
src/main/java/myplayer/service/InvitingService.java
View File

@@ -1,142 +1,142 @@
package myplayer.service; package myplayer.service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import myplayer.entity.Inviting; import myplayer.entity.Inviting;
import myplayer.entity.User; import myplayer.entity.User;
import myplayer.entity.request.InvitingDetails; import myplayer.entity.request.InvitingDetails;
import myplayer.mapper.InvitingMapper; import myplayer.mapper.InvitingMapper;
import myplayer.mapper.UserMapper; import myplayer.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.*; import java.util.*;
@Service @Service
public class InvitingService { public class InvitingService {
@Autowired @Autowired
private InvitingMapper invitingMapper; private InvitingMapper invitingMapper;
@Autowired @Autowired
private UserMapper userMapper; private UserMapper userMapper;
public int sendInvite(String u_id, String f_id, String room) { public int sendInvite(String u_id, String f_id, String room) {
QueryWrapper<Inviting> queryWrapper = new QueryWrapper<>(); QueryWrapper<Inviting> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("inviter", u_id).eq("target", f_id).eq("status",0); queryWrapper.eq("inviter", u_id).eq("target", f_id).eq("status",0);
if (room == null) queryWrapper.isNull("room"); if (room == null) queryWrapper.isNull("room");
else queryWrapper.eq("room", room); else queryWrapper.eq("room", room);
if (!invitingMapper.selectList(queryWrapper).isEmpty()) if (!invitingMapper.selectList(queryWrapper).isEmpty())
//非空返回0 //非空返回0
return 0; return 0;
Inviting inviting = new Inviting(); Inviting inviting = new Inviting();
inviting.setInviter(u_id); inviting.setInviter(u_id);
inviting.setTarget(f_id); inviting.setTarget(f_id);
inviting.setTime(LocalDateTime.now()); inviting.setTime(LocalDateTime.now());
inviting.setStatus(0); inviting.setStatus(0);
if (room != null) inviting.setRoom(room); if (room != null) inviting.setRoom(room);
invitingMapper.insert(inviting); invitingMapper.insert(inviting);
return 1; return 1;
} }
public List<InvitingDetails> getInvitings(String uId) { public List<InvitingDetails> getInvitings(String uId) {
QueryWrapper<Inviting> queryWrapper = new QueryWrapper<>(); QueryWrapper<Inviting> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("target", uId); queryWrapper.eq("target", uId);
queryWrapper.eq("status", 0) queryWrapper.eq("status", 0)
.orderByAsc("time") .orderByAsc("time")
.apply("inviter <> target"); .apply("inviter <> target");
//inviting 所有邀请的查询结果 //inviting 所有邀请的查询结果
List<Inviting> invitings = invitingMapper.selectList(queryWrapper); List<Inviting> invitings = invitingMapper.selectList(queryWrapper);
//inviter_ids 所有邀请者的id //inviter_ids 所有邀请者的id
Set<String> inviter_ids = new HashSet<>(); Set<String> inviter_ids = new HashSet<>();
for (Inviting i : invitings) { for (Inviting i : invitings) {
inviter_ids.add(i.getInviter()); inviter_ids.add(i.getInviter());
} }
if(inviter_ids.isEmpty()) return null; if(inviter_ids.isEmpty()) return null;
QueryWrapper<User> queryWrapper1 = new QueryWrapper<>(); QueryWrapper<User> queryWrapper1 = new QueryWrapper<>();
queryWrapper1.in("u_id", inviter_ids); queryWrapper1.in("u_id", inviter_ids);
List<User> users = userMapper.selectList(queryWrapper1); List<User> users = userMapper.selectList(queryWrapper1);
Map<String, User> userMap = new HashMap<>(); Map<String, User> userMap = new HashMap<>();
for(User u : users) { for(User u : users) {
userMap.put(u.getU_id(), u); userMap.put(u.getU_id(), u);
} }
List<InvitingDetails> requestResult = new ArrayList<>(); List<InvitingDetails> requestResult = new ArrayList<>();
for (Inviting i : invitings) { for (Inviting i : invitings) {
requestResult.add(new InvitingDetails requestResult.add(new InvitingDetails
(i, userMap.get(i.getInviter()).getU_name(), userMap.get(i.getInviter()).getU_avatar())); (i, userMap.get(i.getInviter()).getU_name(), userMap.get(i.getInviter()).getU_avatar()));
} }
return requestResult; return requestResult;
} }
public void acceptInvite(Inviting inviting) { public void acceptInvite(Inviting inviting) {
UpdateWrapper<Inviting> updateWrapper = new UpdateWrapper<>(); UpdateWrapper<Inviting> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("status", 1) updateWrapper.set("status", 1)
.eq("inviter", inviting.getInviter()) .eq("inviter", inviting.getInviter())
.eq("target", inviting.getTarget()) .eq("target", inviting.getTarget())
.eq("status", 0); .eq("status", 0);
invitingMapper.update(updateWrapper); invitingMapper.update(updateWrapper);
} }
public void acceptInvite(Inviting inviting, String room) { public void acceptInvite(Inviting inviting, String room) {
UpdateWrapper<Inviting> updateWrapper = new UpdateWrapper<>(); UpdateWrapper<Inviting> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("status", 1) updateWrapper.set("status", 1)
.eq("inviter", inviting.getInviter()) .eq("inviter", inviting.getInviter())
.eq("target", inviting.getTarget()) .eq("target", inviting.getTarget())
.eq("status", 0) .eq("status", 0)
.eq("room", room); .eq("room", room);
invitingMapper.update(updateWrapper); invitingMapper.update(updateWrapper);
} }
public void refuseInvite(Inviting inviting) { public void refuseInvite(Inviting inviting) {
UpdateWrapper<Inviting> updateWrapper = new UpdateWrapper<>(); UpdateWrapper<Inviting> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("status", 2) updateWrapper.set("status", 2)
.eq("inviter", inviting.getInviter()) .eq("inviter", inviting.getInviter())
.eq("target", inviting.getTarget()) .eq("target", inviting.getTarget())
.eq("status", 0); .eq("status", 0);
invitingMapper.update(updateWrapper); invitingMapper.update(updateWrapper);
} }
public void refuseInvite(Inviting inviting, String room) { public void refuseInvite(Inviting inviting, String room) {
UpdateWrapper<Inviting> updateWrapper = new UpdateWrapper<>(); UpdateWrapper<Inviting> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("status", 2) updateWrapper.set("status", 2)
.eq("inviter", inviting.getInviter()) .eq("inviter", inviting.getInviter())
.eq("target", inviting.getTarget()) .eq("target", inviting.getTarget())
.eq("status", 0) .eq("status", 0)
.eq("room", room); .eq("room", room);
invitingMapper.update(updateWrapper); invitingMapper.update(updateWrapper);
} }
public List<InvitingDetails> getJoinRequest(String rId) { public List<InvitingDetails> getJoinRequest(String rId) {
QueryWrapper<Inviting> queryWrapper = new QueryWrapper<>(); QueryWrapper<Inviting> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("room", rId) queryWrapper.eq("room", rId)
.eq("status", 0) .eq("status", 0)
.apply("inviter = target") .apply("inviter = target")
.orderByAsc("time"); .orderByAsc("time");
List<Inviting> invitings = invitingMapper.selectList(queryWrapper); List<Inviting> invitings = invitingMapper.selectList(queryWrapper);
List<InvitingDetails> requestResult = new ArrayList<>(); List<InvitingDetails> requestResult = new ArrayList<>();
//inviter_ids 所有邀请者的id //inviter_ids 所有邀请者的id
Set<String> inviter_ids = new HashSet<>(); Set<String> inviter_ids = new HashSet<>();
for (Inviting i : invitings) { for (Inviting i : invitings) {
inviter_ids.add(i.getInviter()); inviter_ids.add(i.getInviter());
} }
//获取相关用户的相关信息 //获取相关用户的相关信息
if(inviter_ids.isEmpty()) return null; if(inviter_ids.isEmpty()) return null;
QueryWrapper<User> queryWrapper1 = new QueryWrapper<>(); QueryWrapper<User> queryWrapper1 = new QueryWrapper<>();
queryWrapper1.in("u_id", inviter_ids); queryWrapper1.in("u_id", inviter_ids);
List<User> users = userMapper.selectList(queryWrapper1); List<User> users = userMapper.selectList(queryWrapper1);
Map<String, User> userMap = new HashMap<>(); Map<String, User> userMap = new HashMap<>();
for(User u : users) { for(User u : users) {
userMap.put(u.getU_id(), u); userMap.put(u.getU_id(), u);
} }
//处理返回结果 //处理返回结果
for(Inviting i : invitings) { for(Inviting i : invitings) {
requestResult.add(new InvitingDetails(i, userMap.get(i.getInviter()).getU_name(), userMap.get(i.getInviter()).getU_avatar())); requestResult.add(new InvitingDetails(i, userMap.get(i.getInviter()).getU_name(), userMap.get(i.getInviter()).getU_avatar()));
} }
return requestResult; return requestResult;
} }
} }

44
src/main/java/myplayer/service/OwnService.java
View File

@@ -1,22 +1,22 @@
package myplayer.service; package myplayer.service;
import myplayer.entity.Own; import myplayer.entity.Own;
import myplayer.mapper.OwnMapper; import myplayer.mapper.OwnMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@Service @Service
public class OwnService { public class OwnService {
@Autowired @Autowired
private OwnMapper ownMapper; private OwnMapper ownMapper;
public void joinRoom(String u_id,String r_id){ public void joinRoom(String u_id,String r_id){
ownMapper.insert(new Own(u_id,r_id,2)); ownMapper.insert(new Own(u_id,r_id,2));
} }
public void createPlayroom(Own own){ public void createPlayroom(Own own){
ownMapper.insert(own); ownMapper.insert(own);
} }
} }

168
src/main/java/myplayer/service/PlayroomService.java
View File

@@ -1,84 +1,84 @@
package myplayer.service; package myplayer.service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import myplayer.entity.Own; import myplayer.entity.Own;
import myplayer.entity.Playroom; import myplayer.entity.Playroom;
import myplayer.entity.User; import myplayer.entity.User;
import myplayer.entity.request.Member; import myplayer.entity.request.Member;
import myplayer.mapper.OwnMapper; import myplayer.mapper.OwnMapper;
import myplayer.mapper.PlayroomMapper; import myplayer.mapper.PlayroomMapper;
import myplayer.mapper.UserMapper; import myplayer.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.*; import java.util.*;
@Service @Service
public class PlayroomService { public class PlayroomService {
@Autowired @Autowired
private PlayroomMapper playroomMapper; private PlayroomMapper playroomMapper;
@Autowired @Autowired
private OwnMapper ownMapper; private OwnMapper ownMapper;
@Autowired @Autowired
private UserMapper userMapper; private UserMapper userMapper;
public int playRoomIsExist(String playRoomId) { public int playRoomIsExist(String playRoomId) {
return playroomMapper.playeroomIsExist(playRoomId); return playroomMapper.playeroomIsExist(playRoomId);
} }
public void createPlayroom(Playroom playroom){ public void createPlayroom(Playroom playroom){
playroomMapper.insert(playroom); playroomMapper.insert(playroom);
} }
public List<Playroom> searchPlayroom(String u_id, String Name) { public List<Playroom> searchPlayroom(String u_id, String Name) {
QueryWrapper<Own> queryWrapperOwn = new QueryWrapper<>(); QueryWrapper<Own> queryWrapperOwn = new QueryWrapper<>();
queryWrapperOwn.select("r_id") queryWrapperOwn.select("r_id")
.eq("u_id", u_id); .eq("u_id", u_id);
List<String> joinedRooms = ownMapper.selectObjs(queryWrapperOwn); List<String> joinedRooms = ownMapper.selectObjs(queryWrapperOwn);
QueryWrapper<Playroom> queryWrapper = new QueryWrapper<>(); QueryWrapper<Playroom> queryWrapper = new QueryWrapper<>();
queryWrapper.like("r_name", Name) queryWrapper.like("r_name", Name)
.last("limit 5"); // 模糊查询 .last("limit 5"); // 模糊查询
if(joinedRooms.isEmpty()){ if(joinedRooms.isEmpty()){
System.out.println("无已加入房间，无需排查"); System.out.println("无已加入房间，无需排查");
return playroomMapper.selectList(queryWrapper); return playroomMapper.selectList(queryWrapper);
} }
queryWrapper.notIn("r_id", joinedRooms); queryWrapper.notIn("r_id", joinedRooms);
return playroomMapper.selectList(queryWrapper); return playroomMapper.selectList(queryWrapper);
} }
public List<Playroom> getRooms(String uId) { public List<Playroom> getRooms(String uId) {
QueryWrapper<Own> queryWrapper = new QueryWrapper<>(); QueryWrapper<Own> queryWrapper = new QueryWrapper<>();
queryWrapper.select("r_id") queryWrapper.select("r_id")
.eq("u_id", uId); .eq("u_id", uId);
List<String> joinedRooms = ownMapper.selectObjs(queryWrapper); List<String> joinedRooms = ownMapper.selectObjs(queryWrapper);
if(joinedRooms.isEmpty()){ if(joinedRooms.isEmpty()){
System.out.println( uId+"没有加入任何房间"); System.out.println( uId+"没有加入任何房间");
return null; return null;
} }
QueryWrapper<Playroom> queryWrapperPlayroom = new QueryWrapper<>(); QueryWrapper<Playroom> queryWrapperPlayroom = new QueryWrapper<>();
queryWrapperPlayroom.in("r_id", joinedRooms); queryWrapperPlayroom.in("r_id", joinedRooms);
return playroomMapper.selectList(queryWrapperPlayroom); return playroomMapper.selectList(queryWrapperPlayroom);
} }
public List<Member> getMembers(String r_id) { public List<Member> getMembers(String r_id) {
List<Own> ownList = ownMapper.selectList(new QueryWrapper<Own>().eq("r_id", r_id)); List<Own> ownList = ownMapper.selectList(new QueryWrapper<Own>().eq("r_id", r_id));
Map<String,Integer> ids = new HashMap<>(); Map<String,Integer> ids = new HashMap<>();
List<Member> members = new ArrayList<>(); List<Member> members = new ArrayList<>();
if(ownList != null){ if(ownList != null){
for(Own own : ownList){ for(Own own : ownList){
ids.put(own.getU_id(), own.getRole()); ids.put(own.getU_id(), own.getRole());
} }
List<User> userList = userMapper.selectList(new QueryWrapper<User>().in("u_id", ids)); List<User> userList = userMapper.selectList(new QueryWrapper<User>().in("u_id", ids));
for(User user : userList){ for(User user : userList){
members.add(new Member(user, ids.get(user.getU_id()))); members.add(new Member(user, ids.get(user.getU_id())));
} }
} }
return members; return members;
} }
} }

44
src/main/java/myplayer/service/UserInfoService.java
View File

@@ -1,22 +1,22 @@
package myplayer.service; package myplayer.service;
import myplayer.mapper.UserMapper; import myplayer.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@Service @Service
public class UserInfoService { public class UserInfoService {
@Autowired @Autowired
UserMapper userMapper; UserMapper userMapper;
public String getProfile(String u_id) { public String getProfile(String u_id) {
//获取用户头像 //获取用户头像
return userMapper.getUserAvatar(u_id); return userMapper.getUserAvatar(u_id);
} }
public int updateProfile(String u_id, String avatar) { public int updateProfile(String u_id, String avatar) {
return userMapper.updateAvatar(u_id,avatar); return userMapper.updateAvatar(u_id,avatar);
} }
} }

122
src/main/java/myplayer/service/UserService.java
View File

@@ -1,61 +1,61 @@
package myplayer.service; package myplayer.service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import myplayer.entity.Friend; import myplayer.entity.Friend;
import myplayer.entity.User; import myplayer.entity.User;
import myplayer.mapper.AccountMapper; import myplayer.mapper.AccountMapper;
import myplayer.mapper.FriendMapper; import myplayer.mapper.FriendMapper;
import myplayer.mapper.UserMapper; import myplayer.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List; import java.util.List;
@Service @Service
public class UserService { public class UserService {
@Autowired @Autowired
private UserMapper userMapper; private UserMapper userMapper;
@Autowired @Autowired
private AccountMapper accountMapper; private AccountMapper accountMapper;
@Autowired @Autowired
private FriendMapper friendMapper; private FriendMapper friendMapper;
public User getUserInfo(String u_id) { public User getUserInfo(String u_id) {
return userMapper.selectById(u_id); return userMapper.selectById(u_id);
} }
public void updateName(String uId, String uName) { public void updateName(String uId, String uName) {
userMapper.updateName(uId, uName); userMapper.updateName(uId, uName);
} }
public void updateIntroduction(String uId, String uIntroduction) { public void updateIntroduction(String uId, String uIntroduction) {
userMapper.updateIntroduction(uId, uIntroduction); userMapper.updateIntroduction(uId, uIntroduction);
} }
public void initUser(String uId) { public void initUser(String uId) {
userMapper.initUser(uId); userMapper.initUser(uId);
} }
public List<User> search(String u_id, String Name) { public List<User> search(String u_id, String Name) {
QueryWrapper<Friend> queryWrapper1 = new QueryWrapper<>(); QueryWrapper<Friend> queryWrapper1 = new QueryWrapper<>();
queryWrapper1.select("f_id") queryWrapper1.select("f_id")
.eq("u_id", u_id); .eq("u_id", u_id);
List<String> friends = friendMapper.selectObjs(queryWrapper1); List<String> friends = friendMapper.selectObjs(queryWrapper1);
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("u_name", Name)// 模糊查询 queryWrapper.like("u_name", Name)// 模糊查询
.notIn("u_id", u_id) .notIn("u_id", u_id)
.last("limit 5") .last("limit 5")
; ;
if(friends.isEmpty()) { if(friends.isEmpty()) {
System.out.println("无好友，无需排除"); System.out.println("无好友，无需排除");
return userMapper.selectList(queryWrapper); return userMapper.selectList(queryWrapper);
} }
queryWrapper.notIn("u_id", friends); queryWrapper.notIn("u_id", friends);
return userMapper.selectList(queryWrapper); // 返回查询结果 return userMapper.selectList(queryWrapper); // 返回查询结果
} }
} }

70
src/main/java/myplayer/service/UserStatusService.java
View File

@@ -1,35 +1,35 @@
package myplayer.service; package myplayer.service;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
//用户在线状态服务层 //用户在线状态服务层
@Service @Service
public class UserStatusService { public class UserStatusService {
private final String DB = "myplayer:"; private final String DB = "myplayer:";
@Autowired @Autowired
private StringRedisTemplate stringRedisTemplate; private StringRedisTemplate stringRedisTemplate;
//设置用户在线状态 //设置用户在线状态
public void setUserOnlineStatus(String userId, String status) { public void setUserOnlineStatus(String userId, String status) {
String key = DB + "user:" + userId + ":status"; String key = DB + "user:" + userId + ":status";
stringRedisTemplate.opsForValue().set(key, status); stringRedisTemplate.opsForValue().set(key, status);
} }
//获取用户在线状态 //获取用户在线状态
public String getUserOnlineStatus(String userId) { public String getUserOnlineStatus(String userId) {
String key = DB + "user:" + userId + ":status"; String key = DB + "user:" + userId + ":status";
return stringRedisTemplate.opsForValue().get(key); return stringRedisTemplate.opsForValue().get(key);
} }
//删除用户在线状态 //删除用户在线状态
public void removeUserOnlineStatus(String userId) { public void removeUserOnlineStatus(String userId) {
String key = DB + "user:" + userId + ":status"; String key = DB + "user:" + userId + ":status";
stringRedisTemplate.delete(key); stringRedisTemplate.delete(key);
} }
} }

98
src/main/java/myplayer/utils/AliyunOSS.java
View File

@@ -1,49 +1,49 @@
package myplayer.utils; package myplayer.utils;
import com.aliyun.oss.OSS; import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder; import com.aliyun.oss.OSSClientBuilder;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import org.apache.commons.io.FilenameUtils; import org.apache.commons.io.FilenameUtils;
import java.io.IOException; import java.io.IOException;
import java.util.UUID; import java.util.UUID;
public class AliyunOSS { public class AliyunOSS {
//域名 //域名
public static final String ALI_DOMAIN = "https://for-ever.oss-cn-guangzhou.aliyuncs.com/"; public static final String ALI_DOMAIN = "https://for-ever.oss-cn-guangzhou.aliyuncs.com/";
public static final String endpoint = "http://oss-cn-guangzhou.aliyuncs.com"; public static final String endpoint = "http://oss-cn-guangzhou.aliyuncs.com";
public static final String accessKeyId = "LTAI5tFzCS1DHYt29xcHGigu"; public static final String accessKeyId = "LTAI5tFzCS1DHYt29xcHGigu";
public static final String accessKeySecret = "eweFuUo2sV38QPhGEhbUoeJjMcFw1y"; public static final String accessKeySecret = "eweFuUo2sV38QPhGEhbUoeJjMcFw1y";
public static String uploadImage(MultipartFile file) throws IOException { public static String uploadImage(MultipartFile file) throws IOException {
//生成新的文件名 //生成新的文件名
String originalFilename = file.getOriginalFilename(); String originalFilename = file.getOriginalFilename();
String ext = "." + FilenameUtils.getExtension(originalFilename); String ext = "." + FilenameUtils.getExtension(originalFilename);
String uuid = UUID.randomUUID().toString().replace("-",""); String uuid = UUID.randomUUID().toString().replace("-","");
String fileName = "myplayer/"+ uuid + ext; String fileName = "myplayer/"+ uuid + ext;
//地域节点 //地域节点
//OSS客户端对象 //OSS客户端对象
OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret); OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
ossClient.putObject("for-ever",//仓库名 ossClient.putObject("for-ever",//仓库名
fileName,//文件名 fileName,//文件名
file.getInputStream() file.getInputStream()
); );
ossClient.shutdown(); ossClient.shutdown();
System.out.println("上传成功!"); System.out.println("上传成功!");
return ALI_DOMAIN + fileName; return ALI_DOMAIN + fileName;
} }
public static void deleteImage(String fileName){ public static void deleteImage(String fileName){
int lastSlashIndex = fileName.lastIndexOf('/'); int lastSlashIndex = fileName.lastIndexOf('/');
fileName = fileName.substring(lastSlashIndex - 8); fileName = fileName.substring(lastSlashIndex - 8);
OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret); OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
System.out.println("正在删除!"+fileName); System.out.println("正在删除!"+fileName);
ossClient.deleteObject("for-ever", ossClient.deleteObject("for-ever",
fileName); fileName);
ossClient.shutdown(); ossClient.shutdown();
System.out.println( fileName+"删除成功！"); System.out.println( fileName+"删除成功！");
} }
} }

82
src/main/java/myplayer/utils/Jwt.java
View File

@@ -1,42 +1,42 @@
package myplayer.utils; package myplayer.utils;
import com.auth0.jwt.JWT; import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.algorithms.Algorithm;
import java.util.Date; import java.util.Date;
import java.util.Map; import java.util.Map;
public class Jwt { public class Jwt {
private static final String KEY = "myplayer"; private static final String KEY = "myplayer";
//接收业务数据,生成token并返回 //接收业务数据,生成token并返回
public static String genToken(Map<String, Object> claims) { public static String genToken(Map<String, Object> claims) {
return JWT.create() return JWT.create()
.withClaim("claims", claims) .withClaim("claims", claims)
.withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 7)) .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 7))
.sign(Algorithm.HMAC256(KEY)); .sign(Algorithm.HMAC256(KEY));
} }
//接收token,验证token,并返回业务数据 //接收token,验证token,并返回业务数据
public static Map<String, Object> parseToken(String token) { public static Map<String, Object> parseToken(String token) {
return JWT.require(Algorithm.HMAC256(KEY)) return JWT.require(Algorithm.HMAC256(KEY))
.build() .build()
.verify(token) .verify(token)
.getClaim("claims") .getClaim("claims")
.asMap(); .asMap();
} }
//解析token，获得u_id //解析token，获得u_id
public static String getU_id(String token) { public static String getU_id(String token) {
Map<String,Object> claims = Jwt.parseToken(token); Map<String,Object> claims = Jwt.parseToken(token);
return (String) claims.get("u_id"); return (String) claims.get("u_id");
} }
//解析token，获得account //解析token，获得account
public static String getAccount(String token) { public static String getAccount(String token) {
Map<String,Object> claims = Jwt.parseToken(token); Map<String,Object> claims = Jwt.parseToken(token);
return (String) claims.get("u_account"); return (String) claims.get("u_account");
} }
} }

146
src/main/java/myplayer/utils/Md5.java
View File

@@ -1,73 +1,73 @@
package myplayer.utils; package myplayer.utils;
import java.security.MessageDigest; import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException; import java.security.NoSuchAlgorithmException;
public class Md5 { public class Md5 {
/** /**
* 默认的密码字符串组合，用来将字节转换成 16 进制表示的字符,apache校验下载的文件的正确性用的就是默认的这个组合 * 默认的密码字符串组合，用来将字节转换成 16 进制表示的字符,apache校验下载的文件的正确性用的就是默认的这个组合
*/ */
protected static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; protected static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
protected static MessageDigest messagedigest = null; protected static MessageDigest messagedigest = null;
static { static {
try { try {
messagedigest = MessageDigest.getInstance("MD5"); messagedigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException nsaex) { } catch (NoSuchAlgorithmException nsaex) {
System.err.println(Md5.class.getName() + "初始化失败，MessageDigest不支持MD5。"); System.err.println(Md5.class.getName() + "初始化失败，MessageDigest不支持MD5。");
nsaex.printStackTrace(); nsaex.printStackTrace();
} }
} }
/** /**
* 生成字符串的md5校验值 * 生成字符串的md5校验值
* *
* @param s * @param s
* @return * @return
*/ */
public static String getMD5String(String s) { public static String getMD5String(String s) {
return getMD5String(s.getBytes()); return getMD5String(s.getBytes());
} }
/** /**
* 判断字符串的md5校验码是否与一个已知的md5码相匹配 * 判断字符串的md5校验码是否与一个已知的md5码相匹配
* *
* @param password 要校验的字符串 * @param password 要校验的字符串
* @param md5PwdStr 已知的md5校验码 * @param md5PwdStr 已知的md5校验码
* @return * @return
*/ */
public static boolean checkPassword(String password, String md5PwdStr) { public static boolean checkPassword(String password, String md5PwdStr) {
String s = getMD5String(password); String s = getMD5String(password);
System.out.println(s+"::"+md5PwdStr); System.out.println(s+"::"+md5PwdStr);
return s.equals(md5PwdStr); return s.equals(md5PwdStr);
} }
public static String getMD5String(byte[] bytes) { public static String getMD5String(byte[] bytes) {
messagedigest.update(bytes); messagedigest.update(bytes);
return bufferToHex(messagedigest.digest()); return bufferToHex(messagedigest.digest());
} }
private static String bufferToHex(byte bytes[]) { private static String bufferToHex(byte bytes[]) {
return bufferToHex(bytes, 0, bytes.length); return bufferToHex(bytes, 0, bytes.length);
} }
private static String bufferToHex(byte bytes[], int m, int n) { private static String bufferToHex(byte bytes[], int m, int n) {
StringBuffer stringbuffer = new StringBuffer(2 * n); StringBuffer stringbuffer = new StringBuffer(2 * n);
int k = m + n; int k = m + n;
for (int l = m; l < k; l++) { for (int l = m; l < k; l++) {
appendHexPair(bytes[l], stringbuffer); appendHexPair(bytes[l], stringbuffer);
} }
return stringbuffer.toString(); return stringbuffer.toString();
} }
private static void appendHexPair(byte bt, StringBuffer stringbuffer) { private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
char c0 = hexDigits[(bt & 0xf0) >> 4];// 取字节中高 4 位的数字转换, >>> char c0 = hexDigits[(bt & 0xf0) >> 4];// 取字节中高 4 位的数字转换, >>>
// 为逻辑右移，将符号位一起右移,此处未发现两种符号有何不同 // 为逻辑右移，将符号位一起右移,此处未发现两种符号有何不同
char c1 = hexDigits[bt & 0xf];// 取字节中低 4 位的数字转换 char c1 = hexDigits[bt & 0xf];// 取字节中低 4 位的数字转换
stringbuffer.append(c0); stringbuffer.append(c0);
stringbuffer.append(c1); stringbuffer.append(c1);
} }
} }

54
src/main/java/myplayer/utils/RandomCode.java
View File

@@ -1,27 +1,27 @@
package myplayer.utils; package myplayer.utils;
import java.util.Random; import java.util.Random;
public class RandomCode { public class RandomCode {
private static final Random rand = new Random(); private static final Random rand = new Random();
public static String generateID(){ public static String generateID(){
// 生成一个0到999999的随机数，然后格式化为6位数字字符串 // 生成一个0到999999的随机数，然后格式化为6位数字字符串
return String.format("%06d", rand.nextInt(1000000)); return String.format("%06d", rand.nextInt(1000000));
} }
public static String generateMassiveCode(){ public static String generateMassiveCode(){
// 定义字符集：大写字母和数字 // 定义字符集：大写字母和数字
String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
// 随机生成6位字符串 // 随机生成6位字符串
for (int i = 0; i < 6; i++) { for (int i = 0; i < 6; i++) {
int index = rand.nextInt(characters.length()); int index = rand.nextInt(characters.length());
sb.append(characters.charAt(index)); sb.append(characters.charAt(index));
} }
return sb.toString(); return sb.toString();
} }
} }

94
src/main/java/myplayer/utils/Result.java
View File

@@ -1,48 +1,48 @@
package myplayer.utils; package myplayer.utils;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.Data; import lombok.Data;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
@NoArgsConstructor @NoArgsConstructor
@AllArgsConstructor @AllArgsConstructor
@Data @Data
public class Result<T> { public class Result<T> {
private Integer code; private Integer code;
private String msg; private String msg;
private T data; private T data;
//成功且有返回值 //成功且有返回值
public static <E> Result<E> success(String msg,E data){ public static <E> Result<E> success(String msg,E data){
return new Result<>(200,msg,data); return new Result<>(200,msg,data);
} }
//成功但无返回值 //成功但无返回值
public static Result success(String msg){ public static Result success(String msg){
return new Result<>(200,msg,null); return new Result<>(200,msg,null);
} }
//失败无返回值 //失败无返回值
public static Result error(String msg){ public static Result error(String msg){
return new Result<>(500,msg,null); return new Result<>(500,msg,null);
} }
//服务器内部错误code：500 //服务器内部错误code：500
public static Result serverError(String msg){ public static Result serverError(String msg){
return new Result<>(500,msg,null); return new Result<>(500,msg,null);
} }
//验证码超时错误code：210 //验证码超时错误code：210
public static Result timeout(String msg){ public static Result timeout(String msg){
return new Result<>(210,msg,null); return new Result<>(210,msg,null);
} }
//验证码错误code：211 //验证码错误code：211
public static Result codeError(String msg){ public static Result codeError(String msg){
return new Result<>(211,msg,null); return new Result<>(211,msg,null);
} }
//账户已被注册code:212 //账户已被注册code:212
public static Result createError(String msg) { public static Result createError(String msg) {
return new Result<>(212,msg,null); return new Result<>(212,msg,null);
} }
//账号不存在code：213 //账号不存在code：213
public static Result accountError(String msg) { public static Result accountError(String msg) {
return new Result<>(213,msg,null); return new Result<>(213,msg,null);
} }
} }

102
src/main/java/myplayer/utils/SHA256Util.java
View File

@@ -1,51 +1,51 @@
package myplayer.utils; package myplayer.utils;
import java.security.MessageDigest; import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException; import java.security.NoSuchAlgorithmException;
public class SHA256Util { public class SHA256Util {
/** /**
* 对输入字符串进行SHA-256加密 * 对输入字符串进行SHA-256加密
* @param input 输入字符串 * @param input 输入字符串
* @return 加密后的十六进制字符串 * @return 加密后的十六进制字符串
*/ */
public static String encryptSHA256(String input) { public static String encryptSHA256(String input) {
try { try {
MessageDigest digest = MessageDigest.getInstance("SHA-256"); MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] encodedhash = digest.digest(input.getBytes()); byte[] encodedhash = digest.digest(input.getBytes());
return bytesToHex(encodedhash); return bytesToHex(encodedhash);
} catch (NoSuchAlgorithmException e) { } catch (NoSuchAlgorithmException e) {
throw new RuntimeException("SHA-256 algorithm not found", e); throw new RuntimeException("SHA-256 algorithm not found", e);
} }
} }
/** /**
* 将字节数组转换为十六进制字符串 * 将字节数组转换为十六进制字符串
* @param hash 字节数组 * @param hash 字节数组
* @return 十六进制字符串 * @return 十六进制字符串
*/ */
private static String bytesToHex(byte[] hash) { private static String bytesToHex(byte[] hash) {
StringBuilder hexString = new StringBuilder(2 * hash.length); StringBuilder hexString = new StringBuilder(2 * hash.length);
for (int i = 0; i < hash.length; i++) { for (int i = 0; i < hash.length; i++) {
String hex = Integer.toHexString(0xff & hash[i]); String hex = Integer.toHexString(0xff & hash[i]);
if (hex.length() == 1) { if (hex.length() == 1) {
hexString.append('0'); hexString.append('0');
} }
hexString.append(hex); hexString.append(hex);
} }
return hexString.toString(); return hexString.toString();
} }
/** /**
* 使用用户ID生成盐值，并对密码进行加密 * 使用用户ID生成盐值，并对密码进行加密
* @param password 用户输入的密码 * @param password 用户输入的密码
* @param userId 用户ID * @param userId 用户ID
* @return 加密后的密码哈希值 * @return 加密后的密码哈希值
*/ */
public static String encryptPasswordWithUserId(String password, String userId) { public static String encryptPasswordWithUserId(String password, String userId) {
// 先对用户ID进行SHA-256加密，得到盐值 // 先对用户ID进行SHA-256加密，得到盐值
String salt = encryptSHA256(userId); String salt = encryptSHA256(userId);
// 将盐值与密码拼接后进行SHA-256加密 // 将盐值与密码拼接后进行SHA-256加密
return encryptSHA256(salt + password + salt); return encryptSHA256(salt + password + salt);
} }
} }

84
src/main/java/myplayer/utils/webRTC/WebRTCSignalHandler.java
View File

@@ -1,42 +1,42 @@
package myplayer.utils.webRTC; package myplayer.utils.webRTC;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.web.socket.*; import org.springframework.web.socket.*;
import org.springframework.web.socket.handler.TextWebSocketHandler; import org.springframework.web.socket.handler.TextWebSocketHandler;
import org.json.JSONObject; import org.json.JSONObject;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
@Component @Component
public class WebRTCSignalHandler extends TextWebSocketHandler { public class WebRTCSignalHandler extends TextWebSocketHandler {
private static final ConcurrentHashMap<String, WebSocketSession> sessions = new ConcurrentHashMap<>(); private static final ConcurrentHashMap<String, WebSocketSession> sessions = new ConcurrentHashMap<>();
@Override @Override
public void afterConnectionEstablished(WebSocketSession session) { public void afterConnectionEstablished(WebSocketSession session) {
String sessionId = session.getAttributes().get("u_id").toString(); String sessionId = session.getAttributes().get("u_id").toString();
sessions.put(sessionId, session); sessions.put(sessionId, session);
System.out.println( LocalDateTime.now() + sessionId + ":connected voice websocket server:" +session); System.out.println( LocalDateTime.now() + sessionId + ":connected voice websocket server:" +session);
} }
@Override @Override
protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
String payload = message.getPayload(); String payload = message.getPayload();
JSONObject json = new JSONObject(payload); JSONObject json = new JSONObject(payload);
String to = json.optString("to"); String to = json.optString("to");
String from = json.optString("from"); String from = json.optString("from");
System.out.println(from + "------->" + to +"-"+ payload); System.out.println(from + "------->" + to +"-"+ payload);
if (sessions.containsKey(to)) { if (sessions.containsKey(to)) {
sessions.get(to).sendMessage(new TextMessage(payload)); // 直接转发 SDP/ICE 数据 sessions.get(to).sendMessage(new TextMessage(payload)); // 直接转发 SDP/ICE 数据
}else{ }else{
String msg = "{\"type\":\"status\"," + String msg = "{\"type\":\"status\"," +
"\"status\":" + "\"offline\"}"; "\"status\":" + "\"offline\"}";
sessions.get(from).sendMessage(new TextMessage(msg)); sessions.get(from).sendMessage(new TextMessage(msg));
} }
} }
@Override @Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) { public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
sessions.remove(session.getId()); sessions.remove(session.getId());
} }
} }

146
src/main/java/myplayer/utils/websocket/MessageManager.java
View File

@@ -1,73 +1,73 @@
package myplayer.utils.websocket; package myplayer.utils.websocket;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations; import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import java.util.List; import java.util.List;
@Component @Component
public class MessageManager { public class MessageManager {
private final String DB = "myplayer:"; private final String DB = "myplayer:";
@Autowired @Autowired
private StringRedisTemplate stringRedisTemplate; private StringRedisTemplate stringRedisTemplate;
// public void saveOfflineMessage(String userId, String message) { // public void saveOfflineMessage(String userId, String message) {
// // 使用 Redis 的 List 结构存储离线消息 // // 使用 Redis 的 List 结构存储离线消息
// stringRedisTemplate.opsForList().rightPush("offlineMessages:" + userId, message); // stringRedisTemplate.opsForList().rightPush("offlineMessages:" + userId, message);
// } // }
public void saveMessageKindOne(String targetId, String message) { public void saveMessageKindOne(String targetId, String message) {
// 使用 Redis 的 List 结构存储离线消息 // 使用 Redis 的 List 结构存储离线消息
stringRedisTemplate.opsForList().rightPush(DB+"To:" + targetId, message); stringRedisTemplate.opsForList().rightPush(DB+"To:" + targetId, message);
} }
public void saveMessageKindTwo(String targetId, String message) { public void saveMessageKindTwo(String targetId, String message) {
// 使用 Redis 的 List 结构存储离线消息 // 使用 Redis 的 List 结构存储离线消息
stringRedisTemplate.opsForList().rightPush(DB+":To:"+targetId, message); stringRedisTemplate.opsForList().rightPush(DB+":To:"+targetId, message);
} }
// public List<String> getAndRemoveOfflineMessages(String userId) { // public List<String> getAndRemoveOfflineMessages(String userId) {
// // 获取离线消息 // // 获取离线消息
// ListOperations<String, String> listOps = stringRedisTemplate.opsForList(); // ListOperations<String, String> listOps = stringRedisTemplate.opsForList();
// long size = listOps.size("offlineMessages:" + userId); // long size = listOps.size("offlineMessages:" + userId);
// List<String> messages = listOps.range("offlineMessages:" + userId, 0, size - 1); // List<String> messages = listOps.range("offlineMessages:" + userId, 0, size - 1);
// //
// // 删除已读取消息 // // 删除已读取消息
// listOps.trim("offlineMessages:" + userId, size, -1); // listOps.trim("offlineMessages:" + userId, size, -1);
// return messages; // return messages;
// } // }
public List<String> getAndRemoveMessageKindOne(String targetId) { public List<String> getAndRemoveMessageKindOne(String targetId) {
try { try {
// 获取离线消息 // 获取离线消息
ListOperations<String, String> listOps = stringRedisTemplate.opsForList(); ListOperations<String, String> listOps = stringRedisTemplate.opsForList();
long size = listOps.size(DB+"To:" + targetId); long size = listOps.size(DB+"To:" + targetId);
List<String> messages = listOps.range(DB+"To:" + targetId, 0, size - 1); List<String> messages = listOps.range(DB+"To:" + targetId, 0, size - 1);
// 删除已读取消息 // 删除已读取消息
listOps.trim(DB+"To:" + targetId, size, -1); listOps.trim(DB+"To:" + targetId, size, -1);
return messages; return messages;
} catch (Exception e) { } catch (Exception e) {
System.out.println("ERROR:"+e); System.out.println("ERROR:"+e);
return null; return null;
} }
} }
public List<String> getAndRemoveMessageKindTwo(String targetId) { public List<String> getAndRemoveMessageKindTwo(String targetId) {
try { try {
// 获取离线消息 // 获取离线消息
ListOperations<String, String> listOps = stringRedisTemplate.opsForList(); ListOperations<String, String> listOps = stringRedisTemplate.opsForList();
long size = listOps.size(DB+":To:"+targetId); long size = listOps.size(DB+":To:"+targetId);
List<String> messages = listOps.range(DB+":To:"+targetId, 0, size - 1); List<String> messages = listOps.range(DB+":To:"+targetId, 0, size - 1);
// 删除已读取消息 // 删除已读取消息
listOps.trim(DB+":To:"+targetId, size, -1); listOps.trim(DB+":To:"+targetId, size, -1);
return messages; return messages;
} catch (Exception e) { } catch (Exception e) {
System.out.println("ERROR:"+e); System.out.println("ERROR:"+e);
return null; return null;
} }
} }
} }

378
src/main/java/myplayer/utils/websocket/OnlineStatus.java
View File

@@ -1,189 +1,189 @@
package myplayer.utils.websocket; package myplayer.utils.websocket;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.web.socket.CloseStatus; import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage; import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession; import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler; import org.springframework.web.socket.handler.TextWebSocketHandler;
import java.io.IOException; import java.io.IOException;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.Set; import java.util.Set;
@Component @Component
public class OnlineStatus extends TextWebSocketHandler { public class OnlineStatus extends TextWebSocketHandler {
private final String DB = "myplayer:"; private final String DB = "myplayer:";
@Autowired @Autowired
private StringRedisTemplate stringRedisTemplate; private StringRedisTemplate stringRedisTemplate;
@Autowired @Autowired
private WebSocketSessionManager sessionManager; private WebSocketSessionManager sessionManager;
@Autowired @Autowired
private MessageManager messageManager; private MessageManager messageManager;
@Override @Override
public void afterConnectionEstablished(WebSocketSession session) throws Exception { public void afterConnectionEstablished(WebSocketSession session) throws Exception {
String userId = getUserIdFromSession(session); String userId = getUserIdFromSession(session);
String userName = getUserNameFromSession(session); String userName = getUserNameFromSession(session);
// 检查用户是否已经在线 // 检查用户是否已经在线
WebSocketSession existingSession = sessionManager.getSession(userId); WebSocketSession existingSession = sessionManager.getSession(userId);
System.out.println(existingSession); System.out.println(existingSession);
if (existingSession != null) { if (existingSession != null) {
existingSession.sendMessage(new TextMessage("{\"message\":false," + existingSession.sendMessage(new TextMessage("{\"message\":false," +
"\"system\":true," + "\"system\":true," +
"\"engaged\":\"true\"}")); "\"engaged\":\"true\"}"));
while (sessionManager.getSession(userId) != null) { while (sessionManager.getSession(userId) != null) {
} }
} }
sessionManager.addSession(userId, session); sessionManager.addSession(userId, session);
//redis数据库将用户状态设置为在线 //redis数据库将用户状态设置为在线
stringRedisTemplate.opsForValue().set(DB+"user:" + userId + ":status", "online"); stringRedisTemplate.opsForValue().set(DB+"user:" + userId + ":status", "online");
// 广播该用户在线 // 广播该用户在线
// 由系统代发三类消息 // 由系统代发三类消息
broadcastToFriends(userId, userName, "online"); broadcastToFriends(userId, userName, "online");
// 获取并删除离线一类消息 // 获取并删除离线一类消息
List<String> messages1 = messageManager.getAndRemoveMessageKindOne(userId); List<String> messages1 = messageManager.getAndRemoveMessageKindOne(userId);
for (String msg : messages1) { for (String msg : messages1) {
session.sendMessage(new TextMessage(msg)); // 发送原始 JSON 字符串 session.sendMessage(new TextMessage(msg)); // 发送原始 JSON 字符串
} }
// 获取并删除离线二类消息 // 获取并删除离线二类消息
List<String> messages2 = messageManager.getAndRemoveMessageKindTwo(userId); List<String> messages2 = messageManager.getAndRemoveMessageKindTwo(userId);
for (String msg : messages2) { for (String msg : messages2) {
session.sendMessage(new TextMessage(msg)); // 发送原始 JSON 字符串 session.sendMessage(new TextMessage(msg)); // 发送原始 JSON 字符串
} }
System.out.println(LocalDateTime.now() + " User connected with ID: " + userId); System.out.println(LocalDateTime.now() + " User connected with ID: " + userId);
} }
@Override @Override
protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
String payload = message.getPayload(); String payload = message.getPayload();
System.out.println(payload); System.out.println(payload);
// 解析前端发送的 JSON 消息 // 解析前端发送的 JSON 消息
Map<String, Object> msg = new ObjectMapper().readValue(payload, Map.class); Map<String, Object> msg = new ObjectMapper().readValue(payload, Map.class);
boolean messageKind = (boolean) msg.get("message"); boolean messageKind = (boolean) msg.get("message");
boolean isSystem = (boolean) msg.get("system"); boolean isSystem = (boolean) msg.get("system");
boolean group = (boolean) msg.get("group"); boolean group = (boolean) msg.get("group");
String sender = (String) msg.get("sender"); String sender = (String) msg.get("sender");
String targetId = (String) msg.get("target"); String targetId = (String) msg.get("target");
if (group) { if (group) {
//获取群聊对应的所有用户 //获取群聊对应的所有用户
Set<String> members = stringRedisTemplate.opsForSet().members(DB+targetId); Set<String> members = stringRedisTemplate.opsForSet().members(DB+targetId);
//给所有用户转发该消息 //给所有用户转发该消息
if (members != null) { if (members != null) {
for (String memberId : members) { for (String memberId : members) {
if(Objects.equals(memberId, sender)) continue; if(Objects.equals(memberId, sender)) continue;
WebSocketSession existingSession = sessionManager.getSession(memberId); WebSocketSession existingSession = sessionManager.getSession(memberId);
// 检查目标用户是否在线 // 检查目标用户是否在线
if (existingSession != null) { if (existingSession != null) {
// 发送消息给目标用户//在线的直接发送 // 发送消息给目标用户//在线的直接发送
existingSession.sendMessage(new TextMessage(payload)); existingSession.sendMessage(new TextMessage(payload));
} else { //不在线存入消息队列 } else { //不在线存入消息队列
messageManager.saveMessageKindOne(memberId, payload); messageManager.saveMessageKindOne(memberId, payload);
System.out.println(LocalDateTime.now() + " 消息已存储到 Redis，等待用户上线"); System.out.println(LocalDateTime.now() + " 消息已存储到 Redis，等待用户上线");
} }
} }
} }
} else { } else {
WebSocketSession targetSession = sessionManager.getSession(targetId); WebSocketSession targetSession = sessionManager.getSession(targetId);
// 检查目标用户是否在线 // 检查目标用户是否在线
if (targetSession != null) { if (targetSession != null) {
// 发送消息给目标用户 // 发送消息给目标用户
targetSession.sendMessage(new TextMessage(payload)); targetSession.sendMessage(new TextMessage(payload));
} else if (!isSystem) { } else if (!isSystem) {
if (messageKind) { if (messageKind) {
messageManager.saveMessageKindOne(targetId, payload); messageManager.saveMessageKindOne(targetId, payload);
} else { } else {
messageManager.saveMessageKindTwo(targetId, payload); messageManager.saveMessageKindTwo(targetId, payload);
} }
System.out.println(LocalDateTime.now() + " 消息已存储到 Redis，等待用户上线"); System.out.println(LocalDateTime.now() + " 消息已存储到 Redis，等待用户上线");
} }
} }
} }
@Override @Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception { public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
String userId = getUserIdFromSession(session); String userId = getUserIdFromSession(session);
String userName = getUserNameFromSession(session); String userName = getUserNameFromSession(session);
sessionManager.removeSession(userId); sessionManager.removeSession(userId);
//redis数据库将用户状态设置为离线 //redis数据库将用户状态设置为离线
stringRedisTemplate.opsForValue().set(DB+"user:" + userId + ":status", "offline"); stringRedisTemplate.opsForValue().set(DB+"user:" + userId + ":status", "offline");
// 广播该用户离线 // 广播该用户离线
broadcastToFriends(userId, userName, "offline"); broadcastToFriends(userId, userName, "offline");
System.out.println(LocalDateTime.now() + " User disconnected with ID: " + userId); System.out.println(LocalDateTime.now() + " User disconnected with ID: " + userId);
} }
private String getUserIdFromSession(WebSocketSession session) { private String getUserIdFromSession(WebSocketSession session) {
String userId = (String) session.getAttributes().get("u_id"); String userId = (String) session.getAttributes().get("u_id");
if (userId == null) { if (userId == null) {
System.out.println(LocalDateTime.now() + " User ID is not available"); System.out.println(LocalDateTime.now() + " User ID is not available");
} }
// 提取 session 中的用户信息 // 提取 session 中的用户信息
return userId; return userId;
} }
private String getUserNameFromSession(WebSocketSession session) { private String getUserNameFromSession(WebSocketSession session) {
String u_name = (String) session.getAttributes().get("u_name"); String u_name = (String) session.getAttributes().get("u_name");
if (u_name == null) { if (u_name == null) {
System.out.println(LocalDateTime.now() + " User Name is not available"); System.out.println(LocalDateTime.now() + " User Name is not available");
} }
// 提取 session 中的用户信息 // 提取 session 中的用户信息
return u_name; return u_name;
} }
private void broadcastToFriends(String u_id, String u_name, String status) { private void broadcastToFriends(String u_id, String u_name, String status) {
// 获取用户的好友列表 // 获取用户的好友列表
Set<String> friends = stringRedisTemplate.opsForSet().members(DB+"user:" + u_id + ":friends"); Set<String> friends = stringRedisTemplate.opsForSet().members(DB+"user:" + u_id + ":friends");
if (friends.isEmpty()) { if (friends.isEmpty()) {
System.out.println(LocalDateTime.now() + " 无好友,不发送上下线消息"); System.out.println(LocalDateTime.now() + " 无好友,不发送上下线消息");
return; return;
} }
System.out.println(friends); System.out.println(friends);
// 广播给每个好友 // 广播给每个好友
if (friends != null) { if (friends != null) {
for (String friendId : friends) { for (String friendId : friends) {
WebSocketSession friendsSession = sessionManager.getSession(friendId); WebSocketSession friendsSession = sessionManager.getSession(friendId);
if (friendsSession != null && friendsSession.isOpen()) { if (friendsSession != null && friendsSession.isOpen()) {
//向好友的websocket会话发送状态更新 //向好友的websocket会话发送状态更新
try { try {
String message = "{\"message\":false," + String message = "{\"message\":false," +
"\"system\":true," + "\"system\":true," +
"\"u_name\":\"" + u_name + "\"," + "\"u_name\":\"" + u_name + "\"," +
"\"status\":\"" + status + "\"}"; "\"status\":\"" + status + "\"}";
friendsSession.sendMessage(new TextMessage(message)); friendsSession.sendMessage(new TextMessage(message));
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
} }
} }
} }
} }

66
src/main/java/myplayer/utils/websocket/WebSocketSessionManager.java
View File

@@ -1,34 +1,34 @@
package myplayer.utils.websocket; package myplayer.utils.websocket;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.web.socket.WebSocketSession; import org.springframework.web.socket.WebSocketSession;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
@Component @Component
public class WebSocketSessionManager { public class WebSocketSessionManager {
// 存储 WebSocket 会话与用户 ID 的映射 // 存储 WebSocket 会话与用户 ID 的映射
private static final Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>(); private static final Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>();
// 添加会话 // 添加会话
public void addSession(String userId, WebSocketSession session) { public void addSession(String userId, WebSocketSession session) {
sessions.put(userId, session); sessions.put(userId, session);
} }
// 获取会话 // 获取会话
public WebSocketSession getSession(String userId) { public WebSocketSession getSession(String userId) {
return sessions.get(userId); return sessions.get(userId);
} }
// 移除会话 // 移除会话
public void removeSession(String userId) { public void removeSession(String userId) {
sessions.remove(userId); sessions.remove(userId);
} }
// 获取所有在线会话 // 获取所有在线会话
public Map<String, WebSocketSession> getAllSessions() { public Map<String, WebSocketSession> getAllSessions() {
return sessions; return sessions;
} }
} }

128
src/main/resources/application.yml
View File

@@ -1,64 +1,64 @@
server: server:
# port: 8080 # port: 8080
port: 8443 port: 8443
ssl: ssl:
key-store: classpath:myplayer.merlin.xin.pfx key-store: classpath:myplayer.merlin.xin.pfx
key-store-password: 94c34lkm key-store-password: 94c34lkm
key-store-type: PKCS12 key-store-type: PKCS12
address: 0.0.0.0 address: 0.0.0.0
file: file:
# avatar-dir: C:/uploads/avatars/ # 头像存储目录（Windows 环境） # avatar-dir: C:/uploads/avatars/ # 头像存储目录（Windows 环境）
avatar-dir: /home/myplayer/uploads/avatars # 头像储存目录（Linux 环境） avatar-dir: /home/myplayer/uploads/avatars # 头像储存目录（Linux 环境）
spring: spring:
servlet: servlet:
multipart: multipart:
max-file-size: 50MB max-file-size: 50MB
max-request-size: 10MB max-request-size: 10MB
datasource: datasource:
driver-class-name: com.mysql.cj.jdbc.Driver driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/myplayer url: jdbc:mysql://localhost:3306/myplayer
username: root username: root
password: server2025_xyf_Merlin password: server2025_xyf_Merlin
# username: root # username: root
# password: 3604162 # password: 3604162
redis: redis:
host: localhost host: localhost
port: 6379 port: 6379
password: server2025_xyf_Merlin password: server2025_xyf_Merlin
database: 0 database: 0
timeout: 2000 timeout: 2000
jedis: jedis:
pool: pool:
max-active: 10 max-active: 10
max-idle: 5 max-idle: 5
min-idle: 1 min-idle: 1
mail: mail:
protocol: smtps protocol: smtps
port: 465 port: 465
default-encoding: utf-8 default-encoding: utf-8
host: smtp.163.com host: smtp.163.com
username: addsss2580@163.com username: addsss2580@163.com
password: WDXrkqCJyRTtM7WN password: WDXrkqCJyRTtM7WN
properties: properties:
mail: mail:
smtp: smtp:
auth: true auth: true
ssl: ssl:
enable: false enable: false
required: false required: false
protocols: TLSv1.2 protocols: TLSv1.2
connectiontimeout: 10000 connectiontimeout: 10000
timeout: 15000 timeout: 15000
writetimeout: 10000 writetimeout: 10000
debug: true debug: true
mybatis-plus: mybatis-plus:
configuration: configuration:
map-underscore-to-camel-case: false map-underscore-to-camel-case: false