RedisJson部署
之前公司采用 MongoDB 来作为游戏数据库, 用来持久化玩家的内存信息, 后续 Mongo 母公司因为开源协议等原因导致了后续慢慢抛弃( 要求商业使用公开源码 ).
后续新版本 Redis 自己推出 RedisStack 分支, 主打 JSON 化文档处理, 对于日常简单游戏服务器是没有问题的.
安装配置
这里才用直接配置源之后安装部署就行了:
## Ubuntu/Debian
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
sudo apt-get update
sudo apt-get install redis-stack-server
## RHEL/CentOs
sudo vim /etc/yum.repos.d/redis.repo
# 内容如下:
# [Redis]
# name=Redis
# baseurl=http://packages.redis.io/rpm/rhel7
# enabled=1
# gpgcheck=1
curl -fsSL https://packages.redis.io/gpg > /tmp/redis.key
sudo rpm --import /tmp/redis.key
sudo yum install epel-release
sudo yum install redis-stack-server
没有问题直接系统启动即可:
# 启动服务, 注意 redis 和 redis-stack-server 占用同个端口会冲突
sudo systemctl start redis-stack-server
Java服务
Java 系统依赖:
Java11+SpringBoot2.13+
Maven 引入第三方库( 注意 0.6.4 以下版本支持 Java11+SpringBoot2, 以上版本仅支持 Java17+SpringBoot3):
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<!-- 基础属性 -->
<modelVersion>4.0.0</modelVersion>
<groupId>com.meteorcat.mix</groupId>
<artifactId>td</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>MixTD</name>
<description>WebSocket塔防项目</description>
<!-- 自定义属性 -->
<properties>
<java.version>11</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<spring-boot.version>2.7.6</spring-boot.version>
<spring-om.version>0.6.4-SNAPSHOT</spring-om.version>
<tools-lombok.version>1.18.24</tools-lombok.version>
</properties>
<!-- 依赖库 -->
<dependencies>
<!-- 基础依赖库 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<!-- 引入进程工具 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
<version>${spring-boot.version}</version>
</dependency>
<!-- 官方Redis客户端 -->
<dependency>
<groupId>com.redis.om</groupId>
<artifactId>redis-om-spring</artifactId>
<version>${spring-om.version}</version>
</dependency>
<!-- lombok库 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${tools-lombok.version}</version>
<optional>true</optional>
</dependency>
<!-- 测试库 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>${spring-boot.version}</version>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<!-- 管理库 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<!-- RedisJson依赖库 -->
<repositories>
<repository>
<id>snapshots-repo</id>
<url>https://s01.oss.sonatype.org/content/repositories/snapshots/</url>
</repository>
</repositories>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>11</source>
<target>11</target>
<encoding>UTF-8</encoding>
<!-- 追加动态注解 -->
<annotationProcessorPaths>
<path>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
<version>${spring-boot.version}</version>
</path>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
<version>${tools-lombok.version}</version>
</path>
<path>
<groupId>com.redis.om</groupId>
<artifactId>redis-om-spring</artifactId>
<version>${spring-om.version}</version>
</path>
</annotationProcessorPaths>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version>
<configuration>
<mainClass>com.meteorcat.mix.td.MixTDApplication</mainClass>
</configuration>
<executions>
<execution>
<id>repackage</id>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
注: 官方加了
swagger依赖, 这里不需要这个组件所以不添加.
如果 repositories 配置无效无法下载, 可以在 Maven 的 .m2/settings.xml 更改配置:
<?xml version="1.0"?>
<settings>
<mirrors>
<mirror>
<id>nexus-aliyun</id>
<name>Nexus aliyun</name>
<!-- snapshots-repo 之外的镜像站才需要用阿里镜像 -->
<mirrorOf>*,!snapshots-repo</mirrorOf>
<url>https://maven.aliyun.com/repository/public</url>
</mirror>
</mirrors>
</settings>
applications.properties 配置文件追加:
spring.data.redis.host=your.cloud.db.redislabs.com
spring.data.redis.port=12345
spring.data.redis.password=xxxxxxxx
spring.data.redis.username=default
系统启动类引入数据仓库支持
package com.meteorcat.mix.td;
import com.redis.om.spring.annotations.EnableRedisDocumentRepositories;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 系统启动类
* EnableRedisDocumentRepositories 检索指定包的依赖
* @author MeteorCat
*/
@SpringBootApplication
@EnableRedisDocumentRepositories(basePackages = "com.meteorcat.mix.*")
public class MixTDApplication {
/**
* 启动入口
* @param args 数据参数
*/
public static void main(String[] args) {
SpringApplication.run(MixTDApplication.class, args);
}
}
模型建立
玩家实体数据模型, 用于处理玩家数据实体:
package com.meteorcat.mix.td.model.entity;
import com.redis.om.spring.annotations.Document;
import com.redis.om.spring.annotations.Indexed;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.data.annotation.Id;
import java.util.HashMap;
import java.util.Map;
/**
* 玩家数据文档模型
* @author MeteorCat
*/
@Data
@Document
@RequiredArgsConstructor(staticName = "of")
public class GamePlayerEntity {
/**
* 唯一标识
*/
@Id
@Indexed
private String uuid;
/**
* SDK登录标识UID
*/
@Indexed
private Long uid;
/**
* 服务器对应ID
*/
@Indexed
private Integer serverId;
/**
* 玩家金币资源
*/
private Integer coin = 0;
/**
* 玩家钻石资源[充值道具]
*/
private Integer diamond = 0;
/**
* 玩家道具映射
*/
private Map<String,Integer> item = new HashMap<>(0);
/**
* 最后登录时间
*/
private Long loginTime = 0L;
/**
* 最后登录年月日
*/
private Integer loginYmd = 0;
}
后续就是处理玩家数据工厂, 用来处理检索查找:
package com.meteorcat.mix.td.model.repository;
import com.meteorcat.mix.td.model.entity.GamePlayerEntity;
import com.redis.om.spring.repository.RedisDocumentRepository;
import java.util.Optional;
/**
* 玩家信息仓库
* @author MeteorCat
*/
public interface GamePlayerRepository extends RedisDocumentRepository<GamePlayerEntity,String> {
/**
* 获取玩家实体
* @param uid 第三方UID
* @param serverId 第三方服务器ID
* @return Optional<GamePlayerEntity>
*/
Optional<GamePlayerEntity> findByUidAndServerId(Long uid,Integer serverId);
}
编写测试单元, 测试是否能够写入更新:
package com.meteorcat.mix.td;
import com.meteorcat.mix.td.model.entity.GamePlayerEntity;
import com.meteorcat.mix.td.model.repository.GamePlayerRepository;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Map;
import java.util.Optional;
@Slf4j
@SpringBootTest
class MixTDApplicationTests {
@Autowired
GamePlayerRepository repository;
@Test
void contextLoads() {
// 第三方登录的信息
final Long uid = 1000L;
final Integer serverId = 1;
// 确认实体是否存在
Optional<GamePlayerEntity> entityOptional = repository.findByUidAndServerId(uid,serverId);
if(entityOptional.isEmpty()){
// 不存在玩家, 创建玩家默认实体
GamePlayerEntity entity = GamePlayerEntity.of();
entity.setUid(uid);
entity.setServerId(serverId);
entity.setCoin(0);
entity.setDiamond(0);
entity.setLoginTime(System.currentTimeMillis());
// 写入实体
entity = repository.save(entity);
log.info("Create Player Entity: {}",entity);
}else{
// 存在玩家, 更新玩家对象
GamePlayerEntity entity = entityOptional.get();
entity.setLoginTime(System.currentTimeMillis());
// 登录成功奖励体力道具
final String itemId = "100";
Map<String,Integer> item = entity.getItem();
Integer _ignore = item.containsKey(itemId) ? item.replace(itemId, item.get(itemId) + 1) : item.put(itemId, 1);
// 写入数据
entity = repository.save(entity);
log.info("Update Player Entity: {}",entity);
}
}
}
这里需要注意: 千万留意Key冲突问题, 如果Redis当中有冲突键会导致数据插入异常.
服务编写
数据工厂和数据实体已经完成, 在游戏服务器基本上都是直接放置内存读取, 而只有数据变动才需要更新写入到库之中.
这里就是实现如何挂载在程序内存的操作:
package com.meteorcat.mix.td.model.service;
import com.meteorcat.mix.td.model.entity.GamePlayerEntity;
import com.meteorcat.mix.td.model.repository.GamePlayerRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
/**
* 玩家处理服务
* @author MeteorCat
*/
@Service
public class GamePlayerService {
/**
* 写入仓库对象
*/
@Autowired
private GamePlayerRepository repository;
/**
* 挂载在内存的队列数据
*/
Map<String, GamePlayerEntity> players = new HashMap<>();
/**
* 检索玩家
* @param uid 玩家第三方ID
* @param serverId 玩家服务器ID
* @return Optional<GamePlayerEntity>
*/
public Optional<GamePlayerEntity> findPlayer(Long uid,Integer serverId){
if(repository == null){
return Optional.empty();
}
// 检索内存上的数据, 如果找到直接返回
Optional<GamePlayerEntity> entityOptional = players
.values()
.stream()
.filter(hit->hit.getUid().equals(uid) && hit.getServerId().equals(serverId))
.findFirst();
if(entityOptional.isPresent()){
return entityOptional;
}
// 内存没有玩家实体, 检索数据库
entityOptional = repository.findByUidAndServerId(uid,serverId);
if(entityOptional.isEmpty()){
// 数据库和内存都没有需要直接返回找不到玩家
return entityOptional;
}
// 数据库检索到写入内存返回
GamePlayerEntity entity = entityOptional.get();
players.put(entity.getUuid(),entity);
return Optional.of(entity);
}
/**
* 检索玩家
* @param uuid 主键UUID
* @return Optional<GamePlayerEntity>
*/
public Optional<GamePlayerEntity> findPlayer(String uuid){
if(repository == null){
return Optional.empty();
}
// 检索内存上的uuid, 存在即返回
GamePlayerEntity entity = players.get(uuid);
if(entity != null){
return Optional.of(entity);
}
// 内存上不存在检索数据库
Optional<GamePlayerEntity> entityOptional = repository.findById(uuid);
// 数据库和内存都没有需要直接返回找不到玩家
return entityOptional.map(gamePlayerEntity -> players.put(uuid, gamePlayerEntity));
}
}
编写测试单元内容:
package com.meteorcat.mix.td;
import com.meteorcat.mix.td.model.entity.GamePlayerEntity;
import com.meteorcat.mix.td.model.repository.GamePlayerRepository;
import com.meteorcat.mix.td.model.service.GamePlayerService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Map;
import java.util.Optional;
@Slf4j
@SpringBootTest
class MixTDApplicationTests {
@Autowired
GamePlayerService service;
@Test
void loadService(){
// 第三方登录的信息
final Long uid = 1000L;
final Integer serverId = 1;
// 检索玩家
Optional<GamePlayerEntity> entityOptional = service.findPlayer(uid,serverId);
log.info("Find Player Entity: {}",entityOptional);
}
}
把玩家信息放在类实例当中, 后续都是读取都是走内存而非数据库.