从零开始搭建游戏服务器 第一节 创建一个简单的服务器架构 ...

弁言

由于现在java web太卷了，所以各位偕行可以考虑换一个赛道，做游戏还是很开心的。
本篇教程给新人用于学习游戏服务器的根本知识，给新人们一些学习方向，有什么错误的地方欢迎各位偕行举行讨论。
技术选型

开发语言Java

1. 目前主流的游戏服务器开发语言有C+lua(skynet)、C++、Python、Go、Java。
2. 在广州有些公司习惯使用Erlang。

复制代码

缓存数据库Redis

1. 基本上是唯一的选择，部分小公司制作滚服的游戏由于每个服务器人数不多所以不上Redis。

复制代码

持久化数据库MongoDB

1. 也有部分使用MySQL，最近面试的公司比较多都从MySQL转到MongoDB。我进入公司后也着手将公司内的DB服改造成了使用MongoDB的存储服务。

复制代码

架构设计

团体服务器架构计划使用比较主流的 登录服 + 游戏服 的分布式架构。
登录服用来接收客户端连接，并将其上传的数据发送到对应的游戏服。
可以有多个登录服+多个游戏服用于负载平衡。
正文

本着先完成再完美的原则，从最简单的echo服务器开始。

Echo服务器就是，客户端发什么数据，服务端就原样返回归去。
创建底子架构

IDEA创建项目

我这边用Gradle举行依赖管理，使用的版本为 gradle8.1.1, openjdk17+.
我开发的时候习惯使用最新版本的，所以openjdk我已经升级到20了，不过根本不会用到17以上的特性，所以没有20的用17也足够。
修改build.gradle导入几个底子开发包。
同样的我用的包也都是导入最新的稳定包。

1. subprojects {        // 使用多模块开发，主gradle配置加上subprojects
2.         // ...
3.         dependencies {
4.         //spring
5.         implementation 'org.springframework:spring-context:6.1.4'
6.         //netty
7.         implementation 'io.netty:netty-all:4.1.107.Final'
8.         //日志
9.         implementation group: 'org.slf4j', name: 'slf4j-api', version: '1.7.36'
10.         implementation group: 'ch.qos.logback', name: 'logback-core', version: '1.4.12'
11.         implementation group: 'ch.qos.logback', name: 'logback-access', version: '1.2.11'
12.         implementation group: 'ch.qos.logback', name: 'logback-classic', version: '1.4.14'
13.         implementation group: 'net.logstash.logback', name: 'logstash-logback-encoder', version: '7.4'
14.         //Akka
15.         implementation group: 'com.typesafe.akka', name: 'akka-actor-typed_3', version: '2.8.5'
16.                 //lombok
17.         compileOnly 'org.projectlombok:lombok:1.18.30'
18.         annotationProcessor 'org.projectlombok:lombok:1.18.30'
19.     }
20. }

复制代码

配置多模块

将创建出来的src目次删除，然后按ctrl+alt+shift+s打开项目配置。

在Modules目次下为根项目添加多个module，分别为
client: 测试用的客户端程序
common: 通用模块，通用的代码放在这个模块下面
gameServer: 游戏服模块
loginServer: 登录服模块
前置开发

先在common模块配置一个服务启动器基类BaseMain

1. @Slf4j
2. public abstract class BaseMain {
4.     public boolean shutdownFlag = false;
6.     protected void init() {
7.         initServer();
8.         initListenConsoleInput();
9.     }
11.     /**
12.      * 初始化控制台输入监听
13.      */
14.     private void initListenConsoleInput() {
15.         //region 处理控制台输入，每秒检查一遍 shutdownFlag，为true就跳出循环，执行关闭操作
16.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
17.         while (true) {
18.             if (this.shutdownFlag) {
19.                 log.info("收到kill-15信号,跳出while循环，准备停服");
20.                 break;
21.             }
23.             //线程休眠一秒
24.             try {
25.                 Thread.sleep(1000L);
26.             } catch (InterruptedException e) {
27.                 e.printStackTrace();
28.             }
30.             //处理控制台指令
31.             try {
32.                 if (br.ready()) {
33.                     String str = br.readLine().trim();
34.                     log.info("后台指令: {}", str);
35.                     if ("stop".equals(str)) {
36.                         this.shutdownFlag = true;
37.                     } else {
38.                         handleBackGroundCmd(str);//子类实现
39.                     }
41.                 }
42.             } catch (Exception e) {
43.                 e.printStackTrace();
44.                 log.error("执行命令失败:遇到致命错误");
45.             }
47.         }
48.         //endregion
50.         //region 关闭服务器前执行的逻辑,加上try-catch防止异常导致无法关服
51.         try {
52.             onShutdown();
53.         } catch (Exception e) {
54.             log.error("执行关闭服务器逻辑出现异常了！！！！", e);
55.         }
56.         //endregion
57.     }
59.     /**
60.      * 虚方法：处理控制台传过来的指令
61.      * @param cmd 指令
62.      */
63.     protected abstract void handleBackGroundCmd(String cmd);
65.         /**
66.         * 服务器关闭时的操作
67.         */
68.     protected void onShutdown(){}
70.     /**
71.      * 各个服务初始化要做的事情
72.      */
73.     protected abstract void initServer();
74. }

复制代码

这个抽象类规定了服务器生命周期需要实现的方法
并且实现了initListenConsoleInput()使得程序可以接收控制台中输入的指令。
创建一个SpringUtils，用于快速获取Spring中的bean

1. @Component
2. @Lazy(false)
3. public class SpringUtils implements ApplicationContextAware {
4.     private static ApplicationContext context;
6.     @Override
7.     public void setApplicationContext(ApplicationContext applicationContext) {
8.         context = applicationContext;
9.     }
11.     /**
12.      * 通过字节码获取
13.      * @param beanClass Class
14.      * @return bean
15.      */
16.     public static <T> T getBean(Class<T> beanClass) {
17.         return context.getBean(beanClass);
18.     }
20.     public static <T> T getBean(String beanName) {
21.         return (T) context.getBean(beanName);
22.     }
23. }

复制代码

SpringUtils实现了ApplicationContextAware接口，在程序启动时会自动调用setApplicationContext加载applicationContext。
后面要获取某个bean就使用SpringUtils.getBean就可以。
日志系统配置logback.xml 这部分先不讲。
登录服开发

现在回到loginServer模块中举行开发。
先将common模块导入到loginServer的依赖中。
修改loginServer模块下的build.gradle

1. dependencies {
2.     implementation project(path: ':common')
3. }

复制代码

创建Bean配置类

1. @Configuration
2. @ComponentScan(basePackages = {"org.login", "org.common"}) // 扫描包需要包括login服和common模块的包名
3. public class LoginBeanConfig {
4. }

复制代码

创建主类

1. @Component
2. @Slf4j
3. public class LoginMain extends BaseMain{
4.         public static void main(String[] args) {
5.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LoginBeanConfig.class);
6.         context.start();
7.         LoginMain loginMain = SpringUtils.getBean(LoginMain.class);
8.         loginMain.init();
9.         System.exit(0);
10.     }
11.     @Override
12.     protected void initServer() {
13.                 log.info("LoginServer start!");
14.         }
16.     @Override
17.     protected void handleBackGroundCmd(String cmd) {}
19.     @Override
20.     protected void onShutdown() {
21.         log.warn("LoginServer is ready to shutdown.");
22.     }
23. }

复制代码

运行一下，正常输出LoginServer start！
运行Netty服务

要与客户端举行TCP连接，需要建立socket通道，然后通过socket通道举行数据交互。
传统BIO一个线程一个连接，有新的连接进来时就要创建一个线程，并持续读取数据流，当这个连接发送任何哀求时，会对性能造成严重浪费。
NIO一个线程通过多路复用器可以监听多个连接，通过轮询判断连接是否有数据哀求。
Netty对java原生NIO举行了封装，简化了代码，便于我们的使用。
Netty的包我们之前已经导入过了。
起首我们在common模块创建一个Netty自界说消息处置惩罚类。

1. package org.common.netty;
2. import io.netty.channel.SimpleChannelInboundHandler;
3. /**
4. * netty消息处理器基类
5. */
6. public abstract class BaseNettyHandler extends SimpleChannelInboundHandler<byte[]> {
7. }

复制代码

再创建一个NettyServer用来启动netty服务

1. package org.common.netty;
3. import ...
5. /**
6. * netty服务器
7. */
8. @Slf4j
9. public class NettyServer {
11.     private final BaseNettyHandler handler;
13.     public NettyServer(BaseNettyHandler handler) {
14.         this.handler = handler;
15.     }
17.     public void start(int port) {
18.         final EventLoopGroup boss = new NioEventLoopGroup(1);
19.         final EventLoopGroup worker = new NioEventLoopGroup();
20.         try {
21.             ServerBootstrap bootstrap = new ServerBootstrap();
22.             bootstrap.group(boss, worker);
23.             bootstrap.channel(NioServerSocketChannel.class);
24.             bootstrap.option(ChannelOption.SO_REUSEADDR, true);//允许重用端口
25.             bootstrap.option(ChannelOption.SO_BACKLOG, 512);//允许多少个新请求进入等待
26.             bootstrap.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);//是否使用内存池
27.             bootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
28.             bootstrap.childOption(ChannelOption.TCP_NODELAY, false);
29.             bootstrap.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);//是否使用内存池
30.             bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
31.                 @Override
32.                 protected void initChannel(SocketChannel ch) throws Exception {
33.                     ChannelPipeline pipeline = ch.pipeline();
34.                     // ----------  解码器  -------------
35.                     // 1. 读取数据的长度
36.                     pipeline.addLast(new LengthFieldBasedFrameDecoder(10 * 1024 * 1024, 0, 4, 0, 4));
37.                     // 2. 将ByteBuf转成byte[]
38.                     pipeline.addLast(new ByteToMessageDecoder() {
39.                         @Override
40.                         protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
41.                             if (in.isReadable()) {
42.                                 byte[] bytes = new byte[in.readableBytes()];
43.                                 in.readBytes(bytes);
44.                                 out.add(bytes);
45.                             }
46.                         }
47.                     });
48.                     // ----------  编码器  --------------
49.                     // 2. 添加数据的长度到数据头
50.                     pipeline.addLast(new LengthFieldPrepender(4));
51.                     // 1. 将打包好的数据由byte[]转成ByteBuf
52.                     pipeline.addLast(new MessageToByteEncoder<byte[]>() {
53.                         @Override
54.                         protected void encode(ChannelHandlerContext ctx, byte[] msg, ByteBuf out) throws Exception {
55.                             out.writeBytes(msg);
56.                         }
57.                     });
58.                     // ----------  自定义消息处理器 -----------
59.                     pipeline.addLast(handler);
60.                 }
61.             });
62.             bootstrap.bind(port).sync();
64.         } catch (InterruptedException e) {
65.             throw new RuntimeException(e);
66.         }
67.         Runtime.getRuntime().addShutdownHook(new Thread(() -> {
68.             boss.shutdownGracefully();
69.             worker.shutdownGracefully();
70.         }));
72.         log.info("Start NettyServer ok!");
73.     }
74. }

复制代码

要注意编码器和解码器的入栈顺序。
当接收到消息时，数据会重新向后流入解码器；当发送消息时，会从尾向前流入编码器。
回到loginServer模块，
我们先添加一个配置类用于配置绑定端口login.conf

1. player.port=8081

复制代码

创建配置类LoginConfig

1. /**
2. * 登录服配置文件
3. */
4. @Getter
5. @Component
6. @PropertySource("classpath:login.conf")
7. public class LoginConfig {
8.     @Value("${player.port}")
9.     private int port;
10. }

复制代码

loginServer的自界说消息处置惩罚器LoginNettyHandler

1. @Slf4j
2. @ChannelHandler.Sharable
3. public class LoginNettyHandler extends BaseNettyHandler {
5.     /**
6.      * 收到协议数据
7.      */
8.     @Override
9.     protected void channelRead0(ChannelHandlerContext ctx, byte[] msg) throws Exception {
10.         log.info(new String(msg));
11.         ctx.channel().writeAndFlush(msg);
12.     }
14.     /**
15.      * 建立连接
16.      */
17.     @Override
18.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
19.         InetSocketAddress address = (InetSocketAddress) ctx.channel().remoteAddress();
20.         String ip = address.getAddress().getHostAddress();
22.         if (ctx.channel().isActive()) {
23.             log.info("创建连接—成功:ip = {}", ip);
24.         }
25.     }
27.     /**
28.      * 连接断开
29.      */
30.     @Override
31.     public void channelInactive(ChannelHandlerContext ctx) throws Exception {
32.         log.info("连接断开");
33.     }
35.     @Override
36.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
37.         if (cause instanceof ClosedChannelException) {
38.             return;
39.         }
40.         cause.printStackTrace();
41.         ctx.close();
42.     }
43. }

复制代码

这个自界说消息处置惩罚类将在接收到消息时，将byte[]数据还原成String。
在bean配置类中添加NettyServer的bean

1.         @Bean
2.     NettyServer socketServer() {
3.         LoginNettyHandler handler = new LoginNettyHandler();
4.         return new NettyServer(handler);
5.     }

复制代码

修改LoginMain的initServer方法

1.     protected void initServer() {
2.         LoginConfig config = SpringUtils.getBean(LoginConfig.class);
3.         // netty启动
4.         NettyServer nettyServer = SpringUtils.getBean(NettyServer.class);
5.         nettyServer.start(config.getPort());
6.         log.info("LoginServer start!");
7.     }

复制代码

我们当我们启动LoginMain时，创建了一个Netty服务器，同时绑定了端口8081。然后程序不绝循环监听控制台输入直到输入stop时停机。
我们要注意一下initChannel这块代码，添加了netty自带的长度编码器和解码器，他会在消息头部插入一个消息体的长度，方便程序知道一次协议发送的数据长度。然后添加了ByteBuf转byte[]解码器和byte[]转ByteBuf的编码器，因为我们后面的自界说消息处置惩罚使用byte[]，所以直接在这里举行转换。最后我们添加了一个自界说的消息处置惩罚器LoginNettyHandler用来将收到的信息打印。
至此服务端Netty接入完毕，我们下面编写一个客户端举行测试。
编写客户端举行测试

到client模块举行开发。
创建Netty客户端NettyClient

1. @Slf4j
2. @Component
3. public class NettyClient {
5.     private Channel channel;
7.     public void start(String host, int port) {
8.         final EventLoopGroup group = new NioEventLoopGroup();
9.         try {
10.             Bootstrap bootstrap = new Bootstrap();
11.             bootstrap.group(group);
12.             bootstrap.channel(NioSocketChannel.class);
13.             bootstrap.handler(new ChannelInitializer<SocketChannel>() {
14.                 @Override
15.                 protected void initChannel(SocketChannel ch) throws Exception {
16.                     ChannelPipeline pipeline = ch.pipeline();
17.                     // ----------  解码器  -------------
18.                     // 1. 读取数据的长度
19.                     pipeline.addLast(new LengthFieldBasedFrameDecoder(10 * 1024 * 1024, 0, 4, 0, 4));
20.                     // 2. 将ByteBuf转成byte[]
21.                     pipeline.addLast(new ByteToMessageDecoder() {
22.                         @Override
23.                         protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
24.                             if (in.isReadable()) {
25.                                 byte[] bytes = new byte[in.readableBytes()];
26.                                 in.readBytes(bytes);
27.                                 out.add(bytes);
28.                             }
29.                         }
30.                     });
31.                     // ----------  编码器  --------------
32.                     // 2. 添加数据的长度到数据头
33.                     pipeline.addLast(new LengthFieldPrepender(4));
34.                     // 1. 将打包好的数据由byte[]转成ByteBuf
35.                     pipeline.addLast(new MessageToByteEncoder<byte[]>() {
36.                         @Override
37.                         protected void encode(ChannelHandlerContext ctx, byte[] msg, ByteBuf out) throws Exception {
38.                             out.writeBytes(msg);
39.                         }
40.                     });
41.                     // ----------  自定义消息处理器 -----------
42.                     pipeline.addLast(new SimpleChannelInboundHandler<byte[]>() {
43.                         @Override
44.                         protected void channelRead0(ChannelHandlerContext ctx, byte[] msg) throws Exception {
45.                             log.info(new String(msg));
46.                             ctx.channel().writeAndFlush(msg);
47.                         }
48.                     });
49.                 }
50.             });
51.             ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port)).sync();
52.             channel = future.channel();
54.         } catch (InterruptedException e) {
55.             throw new RuntimeException(e);
56.         }
57.         Runtime.getRuntime().addShutdownHook(new Thread(group::shutdownGracefully));
59.         log.info("Start NettyClient ok!");
60.     }
62.     public void send(byte[] data) {
63.         channel.writeAndFlush(data);
64.     }
66. }

复制代码

与服务端的区别在于：

• 只有一个group用于数据处置惩罚。
  
• 使用的是Bootstrap而非ServerBootstrap。
  
• 最后使用的是bootstrap.connect创建连接到指定地址而非bootstrap.bind。
  

创建ClientMain类，继承BaseMain。

1. @Component
2. @Slf4j
3. public class ClientMain extends BaseMain {
5.     public static void main(String[] args) {
6.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ClientBeanConfig.class);
7.         context.start();
9.         ClientMain clientMain = SpringUtils.getBean(ClientMain.class);
10.         clientMain.init();
12.         System.exit(0);
13.     }
16.     @Override
17.     protected void handleBackGroundCmd(String cmd) {
18.         if (cmd.equals("test")) {
19.             NettyClient nettyClient = SpringUtils.getBean(NettyClient.class);
20.             nettyClient.send("test".getBytes());
21.         }
22.     }
24.     @Override
25.     protected void initServer() {
26.         ClientConfig config = SpringUtils.getBean(ClientConfig.class);
27.         //netty启动
28.         NettyClient nettyClient = SpringUtils.getBean(NettyClient.class);
29.         nettyClient.start(config.getHost(), config.getPort());
30.     }
31. }

复制代码

测试一下，我们先运行服务器，再运行客户端。
在客户端控制台下输入test，就会向服务端发送数据“test”。
服务端收到消息后会原路返回给客户端。
可以乐成举行信息交互
总结

本节一共做了这么几件事：

• 项目的初步创建，通过build.gradle举行多模块依赖包的管理。
  
• Netty服务器的启动，并且不绝监听控制台输入，客户端上行数据的读取。
  
• 编写测试用客户端，与服务器举行数据交互。
  

下一节将举行注册登录的开发，内容将会比较多，感兴趣的点点关注或者留言评论。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。