Java游戏服务器开发流水账(7)网络通信简介

于 2025-05-13 13:03:12 发布
阅读量917 收藏 23
点赞数 34
分类专栏： # java游戏服务器 文章标签： java 游戏 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wgc2k/article/details/147921643
版权

在 Java 游戏服务器开发中，网络通讯是核心组成部分，它主要负责客户端与服务器之间的数据交换。

一、网络通讯基础

1. 网络模型
  • C/S 架构：游戏服务器采用客户端 / 服务器模式，客户端向服务器发送请求，服务器处理请求并返回响应。
  • B/S 架构：部分网页游戏采用浏览器 / 服务器模式，但实时性要求高的游戏通常不采用这种架构。
2. 通讯协议
  • TCP：面向连接的可靠协议，保证数据按序到达，适合需要可靠传输的场景，如 MMORPG。
  • UDP：无连接的不可靠协议，不保证数据顺序和完整性，但延迟低，适合实时性要求高的游戏，如 FPS。
  • HTTP/HTTPS：常用于游戏中的非实时通信，如登录验证、数据同步等。
3. 数据格式
  • 文本协议：如 JSON、XML，易于调试但效率较低。
  • 二进制协议：如 Protobuf、MessagePack，效率高，适合高性能服务器。
  • 自定义协议：根据游戏需求设计的专用协议，通常是二进制格式。

二、Java 网络编程 API

Java 提供了多种网络编程 API，适用于不同的应用场景：

1. 传统的阻塞 IO (BIO)
  • ServerSocket/Socket：基于线程池实现多客户端连接，每个连接占用一个线程。
  • 缺点：线程开销大，不适合高并发场景。
2. 非阻塞 IO (NIO)
  • Selector/Channel：单线程管理多个连接，基于事件驱动，适合高并发场景。
  • 缺点：编程模型复杂，需要处理各种状态。
3. 异步 IO (AIO)
  • AsynchronousServerSocketChannel/AsynchronousSocketChannel：基于回调机制，真正的异步非阻塞，适合长连接、高并发场景。
  • 优点：线程利用率高，编程模型相对简单。
4. 高性能网络框架
  • Netty：基于 NIO 的高性能网络框架，简化了网络编程，广泛应用于游戏服务器开发。
  • Mina：类似 Netty 的网络框架，提供了简单易用的 API。

三、Java AIO 网络通讯实现原理

在前面提供的示例中，我们使用了 Java AIO 实现游戏服务器的网络通讯。下面详细解释其工作原理：

1. 服务器端核心组件
  • AsynchronousChannelGroup：线程池管理，负责处理 IO 操作和回调任务。
  • AsynchronousServerSocketChannel：异步服务器套接字通道，用于监听客户端连接。
  • AsynchronousSocketChannel：异步套接字通道，用于与客户端进行数据交换。
  • CompletionHandler：回调接口，处理 IO 操作完成后的逻辑。
2. 连接建立流程

  1. 创建线程池和服务器通道：

    ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
group = AsynchronousChannelGroup.withThreadPool(executor);
serverChannel = AsynchronousServerSocketChannel.open(group).bind(new InetSocketAddress(port));

  2. 接受客户端连接：

    serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
    @Override
    public void completed(AsynchronousSocketChannel client, Void attachment) {
        // 处理新连接
        acceptConnections(); // 继续接受下一个连接
    }
});
3. 数据读写流程

  • 读取数据：

    channel.read(readBuffer, null, new CompletionHandler<Integer, Void>() {
    @Override
    public void completed(Integer bytesRead, Void attachment) {
        // 处理读取到的数据
        read(); // 继续读取下一次数据
    }
});

  • 写入数据：

    channel.write(writeBuffer, null, new CompletionHandler<Integer, Void>() {
    @Override
    public void completed(Integer bytesWritten, Void attachment) {
        // 继续写入剩余数据
        if (writeBuffer.hasRemaining()) {
            channel.write(writeBuffer, null, this);
        }
    }
});
4. 异步回调机制

Java AIO 的核心是异步回调机制：

  • 当 IO 操作完成时（如连接建立、数据读取），会触发相应的 CompletionHandler 回调方法。
  • 回调方法在 AsynchronousChannelGroup 的线程池中执行，不会阻塞发起 IO 操作的线程。
  • 这种机制使得一个线程可以处理多个客户端连接，大大提高了服务器的并发处理能力。

四、游戏服务器网络优化策略

1. 减少网络延迟
  • 使用 UDP 协议：对于实时性要求高的游戏，如动作游戏、竞技游戏，考虑使用 UDP 协议。
  • 优化服务器位置：将服务器部署在离玩家近的地理位置，减少物理距离造成的延迟。
  • 预测与补偿算法：在客户端实现预测算法，减少玩家操作的感知延迟。
2. 提高吞吐量
  • 使用高性能网络框架：如 Netty，它提供了更好的性能和更简单的编程模型。
  • 优化线程池配置：根据服务器硬件和业务特点调整线程池大小。
  • 采用对象池技术：减少内存分配和垃圾回收开销。
3. 降低带宽消耗
  • 压缩数据：对发送的数据进行压缩，如使用 Zlib、Snappy 等压缩算法。
  • 减少不必要的数据包：只发送必要的数据，避免冗余信息。
  • 使用增量更新：只发送变化的数据，而不是整个状态。
4. 增强可靠性
  • 实现可靠 UDP：在 UDP 协议之上实现可靠性保证，如确认机制、重传机制。
  • 心跳机制：定期发送心跳包，检测连接状态。
  • 断线重连：实现客户端断线重连功能，保持游戏状态。

五、安全与性能监控

1. 网络安全
  • 防止 DDOS 攻击：使用防火墙、流量过滤等技术防御 DDOS 攻击。
  • 数据加密：对敏感数据进行加密传输，如登录信息、支付信息。
  • 协议验证：验证客户端发送的数据包格式和内容，防止恶意攻击。
2. 性能监控
  • 连接数监控：监控当前连接数，防止过多连接导致服务器崩溃。
  • 流量监控：监控网络流量，及时发现异常流量。
  • 响应时间监控：监控服务器响应时间，及时发现性能瓶颈。

六、简单的源码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class GameClient {
    private final String host;
    private final int port;
    private AsynchronousSocketChannel channel;
    private final ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    private final Scanner scanner = new Scanner(System.in);

    public GameClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws IOException {
        // 打开客户端通道
        channel = AsynchronousSocketChannel.open();
        
        // 连接到服务器
        channel.connect(new InetSocketAddress(host, port), null, new CompletionHandler<Void, Void>() {
            @Override
            public void completed(Void result, Void attachment) {
                System.out.println("已连接到服务器: " + host + ":" + port);
                
                // 开始读取服务器消息
                read();
                
                // 启动用户输入处理线程
                new Thread(GameClient.this::handleUserInput).start();
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                System.err.println("连接服务器失败: " + exc.getMessage());
            }
        });
    }

    private void read() {
        readBuffer.clear();
        
        channel.read(readBuffer, null, new CompletionHandler<Integer, Void>() {
            @Override
            public void completed(Integer bytesRead, Void attachment) {
                if (bytesRead == -1) {
                    // 服务器关闭了连接
                    System.out.println("服务器断开连接");
                    close();
                    return;
                }
                
                readBuffer.flip();
                byte[] data = new byte[bytesRead];
                readBuffer.get(data);
                String message = new String(data, StandardCharsets.UTF_8);
                
                // 显示服务器消息
                System.out.print("\r" + message);
                System.out.print("> ");
                
                // 继续读取
                read();
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                System.err.println("读取消息失败: " + exc.getMessage());
                close();
            }
        });
    }

    private void handleUserInput() {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        
        try {
            while (channel.isOpen()) {
                System.out.print("> ");
                String message = reader.readLine();
                
                if (message == null || message.equalsIgnoreCase("/exit")) {
                    close();
                    break;
                }
                
                sendMessage(message);
            }
        } catch (IOException e) {
            System.err.println("读取用户输入失败: " + e.getMessage());
            close();
        }
    }

    private void sendMessage(String message) {
        ByteBuffer buffer = ByteBuffer.wrap((message + "\n").getBytes(StandardCharsets.UTF_8));
        
        channel.write(buffer, null, new CompletionHandler<Integer, Void>() {
            @Override
            public void completed(Integer bytesWritten, Void attachment) {
                // 继续写入剩余数据，如果有的话
                if (buffer.hasRemaining()) {
                    channel.write(buffer, null, this);
                }
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                System.err.println("发送消息失败: " + exc.getMessage());
                close();
            }
        });
    }

    public void close() {
        try {
            if (channel.isOpen()) {
                channel.close();
                System.out.println("客户端已关闭");
            }
        } catch (IOException e) {
            System.err.println("关闭客户端失败: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        GameClient client = new GameClient("localhost", 8080);
        try {
            client.start();
            
            // 保持主线程运行
            Thread.currentThread().join();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
            client.close();
        }
    }
}    
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class GameServer {
    private final int port;
    private AsynchronousChannelGroup group;
    private AsynchronousServerSocketChannel serverChannel;
    private final Map<String, PlayerSession> sessions = new HashMap<>();

    public GameServer(int port) {
        this.port = port;
    }

    public void start() throws IOException {
        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
        group = AsynchronousChannelGroup.withThreadPool(executor);
        
        // 打开服务器通道
        serverChannel = AsynchronousServerSocketChannel.open(group)
                .bind(new InetSocketAddress(port));
        
        System.out.println("游戏服务器启动，监听端口: " + port);
        
        // 开始接受连接
        acceptConnections();
    }

    private void acceptConnections() {
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel client, Void attachment) {
                // 继续接受下一个连接
                acceptConnections();
                
                // 处理新连接
                handleNewConnection(client);
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                System.err.println("接受连接失败: " + exc.getMessage());
            }
        });
    }

    private void handleNewConnection(AsynchronousSocketChannel client) {
        try {
            String sessionId = UUID.randomUUID().toString();
            PlayerSession session = new PlayerSession(sessionId, client, this);
            
            // 存储会话
            sessions.put(sessionId, session);
            
            System.out.println("新玩家连接: " + sessionId + " 来自 " + client.getRemoteAddress());
            
            // 开始读取客户端消息
            session.read();
            
            // 发送欢迎消息
            session.send("欢迎加入游戏服务器! 您的ID: " + sessionId);
            
        } catch (IOException e) {
            System.err.println("处理新连接失败: " + e.getMessage());
            try {
                client.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    public void broadcast(String message, String excludeSessionId) {
        for (PlayerSession session : sessions.values()) {
            if (!session.getSessionId().equals(excludeSessionId)) {
                session.send(message);
            }
        }
    }

    public void removeSession(String sessionId) {
        sessions.remove(sessionId);
        System.out.println("玩家断开连接: " + sessionId);
    }

    public void stop() {
        try {
            // 关闭所有会话
            for (PlayerSession session : sessions.values()) {
                session.close();
            }
            
            // 关闭服务器通道和组
            if (serverChannel != null && serverChannel.isOpen()) {
                serverChannel.close();
            }
            
            if (group != null && !group.isShutdown()) {
                group.shutdownNow();
            }
            
            System.out.println("游戏服务器已停止");
        } catch (IOException e) {
            System.err.println("停止服务器失败: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        GameServer server = new GameServer(8080);
        try {
            server.start();
            
            // 让服务器保持运行
            Thread.currentThread().join();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
            server.stop();
        }
    }
}    
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.StandardCharsets;

public class PlayerSession {
    private final String sessionId;
    private final AsynchronousSocketChannel channel;
    private final GameServer server;
    private final ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    private final ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
    
    // 玩家状态
    private String username;
    private int x, y;
    private boolean isLoggedIn = false;

    public PlayerSession(String sessionId, AsynchronousSocketChannel channel, GameServer server) {
        this.sessionId = sessionId;
        this.channel = channel;
        this.server = server;
    }

    public String getSessionId() {
        return sessionId;
    }

    public void read() {
        readBuffer.clear();
        
        channel.read(readBuffer, null, new CompletionHandler<Integer, Void>() {
            @Override
            public void completed(Integer bytesRead, Void attachment) {
                if (bytesRead == -1) {
                    // 客户端关闭了连接
                    close();
                    return;
                }
                
                readBuffer.flip();
                byte[] data = new byte[bytesRead];
                readBuffer.get(data);
                String message = new String(data, StandardCharsets.UTF_8).trim();
                
                // 处理消息
                handleMessage(message);
                
                // 继续读取
                read();
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                System.err.println("读取消息失败: " + exc.getMessage());
                close();
            }
        });
    }

    private void handleMessage(String message) {
        System.out.println("收到来自 " + sessionId + " 的消息: " + message);
        
        // 简单的命令处理
        if (message.startsWith("/login ")) {
            handleLogin(message.substring(7));
        } else if (message.startsWith("/move ")) {
            handleMove(message.substring(6));
        } else if (message.equals("/logout")) {
            handleLogout();
        } else if (message.equals("/players")) {
            sendPlayerList();
        } else {
            // 广播消息给其他玩家
            if (isLoggedIn) {
                server.broadcast("[" + username + "] " + message, sessionId);
            } else {
                send("请先登录 /login <用户名>");
            }
        }
    }

    private void handleLogin(String username) {
        if (isLoggedIn) {
            send("您已经登录为 " + this.username);
            return;
        }
        
        this.username = username;
        this.isLoggedIn = true;
        this.x = 0;
        this.y = 0;
        
        send("登录成功，欢迎 " + username);
        server.broadcast(username + " 加入了游戏", sessionId);
    }

    private void handleMove(String direction) {
        if (!isLoggedIn) {
            send("请先登录 /login <用户名>");
            return;
        }
        
        switch (direction.toLowerCase()) {
            case "up": y--; break;
            case "down": y++; break;
            case "left": x--; break;
            case "right": x++; break;
            default: 
                send("无效的移动方向: " + direction);
                return;
        }
        
        send("您移动到了位置 (" + x + ", " + y + ")");
        server.broadcast(username + " 移动到了位置 (" + x + ", " + y + ")", sessionId);
    }

    private void handleLogout() {
        if (!isLoggedIn) {
            send("您尚未登录");
            return;
        }
        
        server.broadcast(username + " 离开了游戏", sessionId);
        this.isLoggedIn = false;
        send("您已登出");
    }

    private void sendPlayerList() {
        StringBuilder builder = new StringBuilder("在线玩家列表:\n");
        // 实际应用中应该遍历所有玩家并添加到列表
        builder.append(username).append(" (").append(x).append(", ").append(y).append(")\n");
        send(builder.toString());
    }

    public void send(String message) {
        writeBuffer.clear();
        writeBuffer.put((message + "\n").getBytes(StandardCharsets.UTF_8));
        writeBuffer.flip();
        
        channel.write(writeBuffer, null, new CompletionHandler<Integer, Void>() {
            @Override
            public void completed(Integer bytesWritten, Void attachment) {
                // 继续写入剩余数据，如果有的话
                if (writeBuffer.hasRemaining()) {
                    channel.write(writeBuffer, null, this);
                }
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                System.err.println("发送消息失败: " + exc.getMessage());
                close();
            }
        });
    }

    public void close() {
        try {
            if (channel.isOpen()) {
                channel.close();
                server.removeSession(sessionId);
            }
        } catch (IOException e) {
            System.err.println("关闭会话失败: " + e.getMessage());
        }
    }
}

六、总结

虽然AIO 提供了高效的异步非阻塞编程模型，适合开发高性能的游戏服务器。但是手撸Java 游戏服务器的网络通讯相对比较复杂，需要综合考虑性能、可靠性、安全性等多个方面。上面的代码是最简单的实现

在实际开发中，通常会使用成熟的网络框架如 Netty，以简化开发流程并提高系统稳定性。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值