基于Netty与Java构建高并发MUD游戏服务器：架构设计与工程实践-平芜编程栈

简介：本资源是吉林大学Java程序设计课程高分课程设计成果——MUD多人在线文字冒险游戏系统源码，面向Java初学者及课程设计、期末大作业、毕业设计实践者，解决网络编程、多线程会话管理与实时交互等核心教学难点。压缩包共40个文件，含10个核心Java源文件（实现用户登录、命令解析、房间交互等逻辑）、16个编译后class文件、6个Eclipse项目配置备份（.zbak/.prefs/.project等），以及说明文档与工程元数据，整体仅68KB，轻量易部署。已有41人学习下载，资源经完整调试可直接运行，代码注释详尽，模块划分清晰（如com.star包下分层组织网络通信、游戏世界、玩家状态等组件），特别适合理解Socket通信、线程安全会话控制与MVC式架构演进过程，是少有的兼具教学规范性与工程可用性的Java实战范例。

1. 项目概述：从“泥巴”到现代架构的跨越

提起MUD，很多年轻开发者可能觉得陌生，但对我们这些经历过拨号上网时代的老程序员来说，它承载着一段独特的记忆。MUD，全称Multi-User Dungeon，中文常被戏称为“泥巴”，是纯文字多人在线游戏的鼻祖。没有图形界面，所有交互都通过文字命令完成，玩家在由ASCII字符描绘的世界里探险、社交、战斗。这个“吉大课程设计高分项目”的核心，就是要求我们用现代Java技术栈，去复现并重构这样一个经典的游戏系统。这不仅仅是完成一个作业，更是一次对网络编程、并发处理、对象建模和软件工程思想的综合演练。项目要求实现一个稳定的、可扩展的、支持多玩家同时在线的文字游戏服务器，并配套完整的客户端和清晰的源码。对于计算机专业的学生而言，能独立完成这样一个项目，在面试中绝对是碾压级的存在，因为它几乎覆盖了“Java八股文”里所有核心知识点的实际应用场景：Socket网络通信、多线程与线程池、I/O模型、集合框架、设计模式、序列化，乃至简单的数据库操作。

2. 核心需求与架构设计解析

2.1 需求拆解：不止于“能玩”

一个合格的MUD系统，远不止是让几个客户端连上来发发消息那么简单。我们需要拆解出它的核心功能模块：

网络通信层：这是游戏的血管。需要稳定处理大量玩家的并发连接，高效地接收指令、广播消息。是选择传统的阻塞式Socket+线程池，还是NIO，抑或是直接使用Netty框架？这需要权衡开发效率、学习成本和性能。
游戏世界模型层：这是游戏的骨骼与血肉。需要抽象出房间（Room）、物品（Item）、玩家（Player）、非玩家角色（NPC）、怪物（Monster）等核心实体，并定义它们之间的关系（如房间的出口、物品的归属、玩家的状态）。
命令解析与执行层：这是游戏的大脑。玩家输入的“look”、“go east”、“get sword”等自然语言式的命令，需要被精准地解析成游戏逻辑能理解的操作，并触发相应的状态改变和反馈。
游戏逻辑与状态管理：这是游戏的灵魂。包括战斗系统（回合制或即时计算）、经验升级、物品交易、任务系统等。所有玩家的状态变更必须保证一致性和安全性，尤其是在并发环境下。
数据持久化层：虽然MUD世界可以重置，但玩家的角色数据（等级、装备、位置）通常需要保存。是使用文件序列化，还是接入MySQL等数据库？这决定了数据的可靠性和查询效率。

2.2 技术选型与架构设计

基于上述需求，一个高内聚、低耦合的分层架构是成功的关键。我推荐并采用以下设计：

整体架构：采用经典的三层架构——表现层（网络通信）、业务逻辑层（游戏核心）、数据访问层（持久化）。各层之间通过接口或定义良好的模型对象进行交互。
通信框架选择：为了聚焦于游戏逻辑本身，避免在底层网络I/O上耗费过多精力，我强烈推荐使用Netty。它是一个高性能的异步事件驱动网络框架，完美解决了传统BIO的线程资源瓶颈和NIO的编程复杂度问题。用它来处理连接管理、编解码、心跳检测等“脏活累活”，让我们可以更专注于业务逻辑。
线程模型：结合Netty，我们采用其主从Reactor线程模型。主线程组（BossGroup）负责接收连接，从线程组（WorkerGroup）负责处理Channel的I/O读写。游戏逻辑运算应避免在I/O线程中长时间执行，可以提交到独立的业务线程池中，防止阻塞网络通信。
数据存储：对于课程设计级别的项目，使用JSON文件序列化存储玩家数据是一个简单高效的方案。使用Jackson或Gson库，将Player对象序列化为JSON文件，每个玩家一个文件。如果追求更正式和可查询，可以集成轻量级嵌入式数据库如H2 Database或SQLite，通过JDBC或MyBatis进行操作。

注意：架构设计没有银弹。如果课程时间极其紧张，且对并发量要求不高（如<50人），使用ServerSocket配合ExecutorService线程池是快速出活的选择。但若想拿高分并深入理解高并发，Netty是更值得投入的学习方向。

3. 核心模块实现详解

3.1 网络通信模块（基于Netty）

这是系统的入口。我们首先要定义客户端与服务器之间的通信协议。为了简单和高效，我采用了“自定义文本协议”，即每条消息以换行符\n作为分隔符。

服务器启动类MudServer：

public class MudServer { private final int port; public MudServer(int port) { this.port = port; } public void run() throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(1); // 主线程组 EventLoopGroup workerGroup = new NioEventLoopGroup(); // 工作线程组 try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) { ch.pipeline().addLast( new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()), // 解决粘包拆包 new StringDecoder(CharsetUtil.UTF_8), new StringEncoder(CharsetUtil.UTF_8), new MudServerHandler() // 核心业务处理器 ); } }) .option(ChannelOption.SO_BACKLOG, 128) .childOption(ChannelOption.SO_KEEPALIVE, true); ChannelFuture f = b.bind(port).sync(); f.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } }

核心业务处理器MudServerHandler：这个类继承SimpleChannelInboundHandler<String>，负责处理每条具体的客户端命令。它是网络层与游戏逻辑层的桥梁。

public class MudServerHandler extends SimpleChannelInboundHandler<String> { private Player player; // 关联的玩家对象 private ChannelHandlerContext ctx; @Override public void channelActive(ChannelHandlerContext ctx) { this.ctx = ctx; // 1. 新连接建立，发送欢迎信息 ctx.writeAndFlush("欢迎来到JavaMUD世界！请输入您的角色名进行登录或注册：\n"); } @Override protected void channelRead0(ChannelHandlerContext ctx, String msg) { // 2. 收到客户端消息 if (player == null) { // 处理登录/注册逻辑 handleLogin(msg.trim()); } else { // 已登录状态，将命令交给游戏世界引擎处理 String response = World.getInstance().processCommand(player, msg.trim()); ctx.writeAndFlush(response + "\n"); } } private void handleLogin(String name) { // 从文件或数据库加载玩家数据，或创建新玩家 player = Player.loadFromFile(name); // 示例：从文件加载 if (player == null) { player = new Player(name, ctx.channel()); player.saveToFile(); ctx.writeAndFlush("角色创建成功！欢迎新冒险者 " + name + "。\n"); } else { player.setChannel(ctx.channel()); ctx.writeAndFlush("欢迎回来，" + name + "！\n"); } // 显示玩家当前位置描述 ctx.writeAndFlush(player.getCurrentRoom().getFullDescription()); } // ... 处理连接断开等事件 }

实操心得：Netty的ChannelHandlerContext(ctx) 是与特定客户端连接绑定的。我们需要将Player对象与这个ctx关联起来，以便后续向该玩家单独推送消息（如私聊、战斗伤害）。同时，使用DelimiterBasedFrameDecoder是解决TCP粘包/拆包问题的标准做法，非常重要。

3.2 游戏世界模型设计

这是面向对象设计能力的集中体现。我们需要构建一个清晰、可扩展的类体系。

GameObject(抽象基类)：所有游戏实体的父类，包含通用属性如id,name,description。
Room(房间)：继承GameObject。核心属性是Map<String, Room> exits，用于存储“方向-房间”的映射。例如exits.put("east", room123)。还需要一个List<Item> items和List<Player> players来管理房间内的物品和玩家。
Item(物品)：继承GameObject。可以有weight,isTakable等属性。可以进一步派生出Weapon（武器）、Potion（药水）等子类。
Creature(生物抽象类)：继承GameObject，包含health,attack,defense等战斗属性。
- Player(玩家)：继承Creature。增加level,experience,inventory（背包），以及一个关键的Channel属性（用于网络回写）。
- NPC/Monster(非玩家角色/怪物)：继承Creature。可以包含简单的AI行为，如定时巡逻、主动攻击。

世界管理器World(单例模式)：这是游戏世界的总控中心，采用单例模式确保全局唯一。

public class World { private static World instance; private Map<String, Room> rooms; // 房间ID到房间对象的映射 private Map<String, Player> onlinePlayers; // 在线玩家映射 private World() { rooms = new HashMap<>(); onlinePlayers = new ConcurrentHashMap<>(); // 使用并发安全的Map initializeWorld(); // 初始化世界，创建房间、物品、NPC } public static World getInstance() { if (instance == null) { synchronized (World.class) { if (instance == null) { instance = new World(); } } } return instance; } // 核心方法：处理玩家命令 public String processCommand(Player player, String rawCommand) { // 1. 解析命令 String[] parts = rawCommand.split("\\s+"); String verb = parts[0].toLowerCase(); String target = parts.length > 1 ? parts[1] : null; // 2. 分派到具体的命令处理器 switch (verb) { case "look": return player.getCurrentRoom().getFullDescription(); case "go": return handleMove(player, target); case "get": return handleGetItem(player, target); case "drop": return handleDropItem(player, target); case "say": String message = rawCommand.substring(verb.length()).trim(); return handleSay(player, message); case "attack": return handleAttack(player, target); // ... 其他命令 default: return "我不理解 '" + verb + "' 这个命令。"; } } private String handleMove(Player player, String direction) { Room current = player.getCurrentRoom(); Room nextRoom = current.getExit(direction); if (nextRoom == null) { return "那个方向没有路。"; } // 广播离开和进入消息 current.broadcast(player.getName() + "离开了房间，向" + direction + "走去。", player); player.setCurrentRoom(nextRoom); nextRoom.broadcast(player.getName() + "进入了房间。", player); return nextRoom.getFullDescription(); // 只给移动的玩家返回新房间描述 } private String handleSay(Player player, String message) { String formattedMsg = player.getName() + "说道: \"" + message + "\""; player.getCurrentRoom().broadcast(formattedMsg, null); // 广播给房间内所有人 return "你说: \"" + message + "\""; // 给自己一个回显 } // ... 其他命令处理方法 }

设计要点：World类集中了所有游戏状态和逻辑。使用ConcurrentHashMap管理在线玩家是线程安全的关键。命令处理采用“动词-目标”的简单解析模式，足够应对MUD的基本需求。广播功能是MUD社交性的核心，需要精心设计，避免给说话者自己发送重复信息。

3.3 命令系统与解析器

命令系统是玩家与游戏交互的桥梁。一个健壮的命令解析器能极大提升游戏体验。

我们可以设计一个Command接口和一系列实现类：

public interface Command { String execute(Player player, String[] args); } public class LookCommand implements Command { @Override public String execute(Player player, String[] args) { return player.getCurrentRoom().getFullDescription(); } } // GoCommand, GetCommand, DropCommand... 类似

然后，在World中维护一个Map<String, Command> commandMap。这样，processCommand方法就演变为：

public String processCommand(Player player, String rawCommand) { String[] parts = rawCommand.split("\\s+"); String verb = parts[0].toLowerCase(); Command cmd = commandMap.get(verb); if (cmd != null) { String[] args = Arrays.copyOfRange(parts, 1, parts.length); return cmd.execute(player, args); } else { return "未知命令。输入 'help' 查看帮助。"; } }

这种设计将每个命令的逻辑封装在独立的类中，符合“开闭原则”，新增命令只需添加新的实现类并注册到Map中即可，非常清晰和易于扩展。

3.4 数据持久化设计

以JSON序列化玩家数据为例。我们需要为Player类实现序列化和反序列化方法。

首先，确保Player类中的关键属性（如name,health,currentRoomId等）都有getter和setter方法。避免序列化网络相关的Channel等临时属性（可以用transient关键字修饰）。

使用Jackson库：

public class Player { private String name; private int health; private String currentRoomId; private transient Channel channel; // 不序列化 // ... 其他属性和方法 public void saveToFile() { ObjectMapper mapper = new ObjectMapper(); mapper.enable(SerializationFeature.INDENT_OUTPUT); // 美化输出 try { File file = new File("data/players/" + name + ".json"); mapper.writeValue(file, this); } catch (IOException e) { e.printStackTrace(); } } public static Player loadFromFile(String name) { ObjectMapper mapper = new ObjectMapper(); File file = new File("data/players/" + name + ".json"); if (file.exists()) { try { return mapper.readValue(file, Player.class); } catch (IOException e) { e.printStackTrace(); } } return null; } }

注意事项：保存的currentRoomId是一个字符串标识符，在加载玩家后，需要调用World.getInstance().getRoom(roomId)来重新关联到内存中的Room对象。这就是为什么模型设计中房间要有唯一ID的原因。

4. 高级特性与性能优化实战

4.1 实现回合制战斗系统

战斗是MUD游戏的核心乐趣之一。我们实现一个简单的回合制战斗。

在World类中添加战斗处理方法：

private String handleAttack(Player player, String targetName) { Room room = player.getCurrentRoom(); Creature target = room.findCreature(targetName); // 在房间内查找生物 if (target == null) { return "这里没有叫 '" + targetName + "' 的生物。"; } if (target == player) { return "你不能攻击自己。"; } // 进入战斗状态 player.setInCombatWith(target); target.setInCombatWith(player); // 计算伤害 int damage = Math.max(1, player.getAttack() - target.getDefense() / 2); target.setHealth(target.getHealth() - damage); String resultMsg = player.getName() + "攻击了" + target.getName() + "，造成了" + damage + "点伤害。"; room.broadcast(resultMsg, null); // 检查目标是否死亡 if (target.getHealth() <= 0) { String deathMsg = target.getName() + "被击败了！"; room.broadcast(deathMsg, null); room.removeCreature(target); // 玩家获得经验 if (target instanceof Monster) { int expGained = ((Monster) target).getExpReward(); player.gainExp(expGained); player.receiveMessage("你获得了" + expGained + "点经验值。"); } player.setInCombatWith(null); return resultMsg + "\n" + deathMsg; } // 目标反击（简单的AI） if (target instanceof Monster) { // 可以在这里加入怪物反击逻辑，或者通过一个独立的战斗Tick线程来处理 return resultMsg + "\n" + target.getName() + "愤怒地盯着你，准备反击！"; } return resultMsg; }

优化思考：上述是即时结算的简单战斗。更复杂的实现可以引入“战斗轮”概念，使用一个独立的CombatScheduler线程来定时（如每5秒）处理一次战斗回合，这样可以让多个玩家同时与怪物战斗，并且支持更复杂的技能冷却等机制。

4.2 使用线程池优化逻辑处理

尽管Netty的I/O线程非阻塞，但复杂的游戏逻辑（如路径查找、大量计算）仍可能耗时。为了避免阻塞I/O线程（Netty的WorkerGroup），我们应该将耗时业务逻辑提交到独立的业务线程池。

在World类中初始化一个业务线程池：

private ExecutorService businessExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);

修改processCommand方法，对于可能耗时的命令（如复杂的search、craft），使用线程池异步执行：

public void processCommandAsync(Player player, String rawCommand, Consumer<String> callback) { businessExecutor.submit(() -> { String result = processCommand(player, rawCommand); // 同步处理逻辑 // 将结果写回客户端（注意，此操作需回到Netty的I/O线程） player.getChannel().eventLoop().execute(() -> { player.getChannel().writeAndFlush(result + "\n"); }); }); }

在MudServerHandler中，对于标记为耗时的命令，调用processCommandAsync而非直接调用processCommand。这样，Netty的I/O线程得以快速释放，专注于处理网络数据收发，极大提升了服务器的并发吞吐能力。

4.3 世界状态保存与加载

除了玩家数据，整个游戏世界（房间、物品、NPC的初始状态）也需要持久化。我们可以在World的initializeWorld()方法中，从JSON配置文件中加载世界配置，而不是将初始化逻辑硬编码在代码里。

创建一个world_config.json文件描述世界：

{ "rooms": [ { "id": "town_square", "name": "中央广场", "description": "一个宽阔的石板广场，人来人往。", "exits": { "north": "blacksmith", "east": "tavern" }, "items": [{"id": "rusty_sword", "name": "生锈的铁剑"}], "npcs": [{"id": "old_man", "name": "老村长"}] }, // ... 更多房间 ] }

然后在World初始化时，使用Jackson解析这个JSON文件，动态创建所有的Room、Item、NPC对象。这使得游戏世界的修改无需重新编译代码，直接编辑配置文件即可，非常灵活。

5. 客户端实现与系统联调

5.1 简易命令行客户端

服务器端完成后，需要一个客户端进行连接测试。一个最简单的Java命令行客户端如下：

public class MudClient { public static void main(String[] args) throws Exception { String host = "localhost"; int port = 8888; try (Socket socket = new Socket(host, port); BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8)); PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8), true); BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))) { // 启动一个线程专门接收服务器消息 new Thread(() -> { String serverResponse; try { while ((serverResponse = in.readLine()) != null) { System.out.println(serverResponse); } } catch (IOException e) { System.out.println("与服务器连接断开。"); } }).start(); // 主线程读取用户输入并发送 String userInput; while ((userInput = stdIn.readLine()) != null) { out.println(userInput); } } } }

这个客户端使用两个线程，一个阻塞读取服务器推送的消息并打印到控制台，另一个阻塞读取用户在控制台的输入并发送给服务器。虽然简单，但足以进行所有功能测试。

5.2 系统集成测试与调试

联调是项目最易出错的阶段。以下是我总结的测试清单和调试技巧：

基础连接测试：先运行服务器，再运行客户端，看能否看到欢迎语。
命令流测试：按顺序测试：登录/注册 -> look -> go [方向] -> get/drop物品 -> say。观察服务器广播是否正确（是否给自己发了重复消息）。
并发压力测试：编写一个简单的多线程测试脚本，模拟几十个客户端同时连接、登录、发送随机命令。观察服务器CPU和内存使用情况，以及是否有连接失败、命令响应丢失或错乱。
- 工具：可以使用Apache JMeter或自己写多线程程序。
- 关键指标：连接成功率、平均响应时间、错误率。
状态一致性测试：让两个玩家A和B进入同一个房间。A丢弃一件物品，B是否能立刻look看到？A离开房间，B的look描述是否及时更新？这测试了World单例中状态管理的正确性。
数据持久化测试：创建一个角色，进行一些操作（如移动、获取物品），然后退出客户端。重新登录，检查角色状态（位置、背包）是否恢复。
异常处理测试：输入不存在的命令、去不存在的方向、获取不存在的物品。服务器应返回友好的错误提示，而不是崩溃或抛出异常到客户端。

调试技巧：

服务器端日志：务必在关键位置（如连接建立/断开、命令处理前后、广播消息时）添加日志（使用SLF4J+Logback）。日志要包含玩家ID、房间ID、命令内容等上下文信息。
Netty的LoggingHandler：在Netty的pipeline中添加LoggingHandler(LogLevel.DEBUG)，可以详细查看网络字节流的收发情况，对调试协议问题非常有帮助。
使用JVisualVM或Arthas：在压力测试时监控服务器JVM的线程状态、堆内存、CPU使用情况，排查是否有线程阻塞或内存泄漏。

6. 常见问题排查与性能调优实录

在开发过程中，我遇到了不少典型问题，这里记录下排查思路和解决方案。

问题现象	可能原因	排查步骤与解决方案
客户端收不到服务器广播的消息	1. 广播逻辑错误，漏掉了发消息者。 2. 玩家Channel未正确关联或已关闭。 3. 消息未以换行符`\n`结尾。	1. 检查`Room.broadcast()`方法，确保循环遍历了房间内所有玩家，并正确排除了发信人（如果需要）。 2. 在`Player`登录和退出时，打印日志确认其`Channel`的绑定和解绑。 3. 在服务器发送消息处，确认字符串末尾添加了`\n`。使用Wireshark或Netty的LoggingHandler抓包查看。
多个玩家同时操作时，物品状态错乱（如一个物品被两人同时捡起）	对共享资源（如房间的物品列表）的访问没有进行同步控制，导致竞态条件。	为`Room`类的关键方法（如`removeItem`,`addItem`）添加`synchronized`关键字，或者使用`ConcurrentHashMap`、`CopyOnWriteArrayList`等并发集合来管理物品和玩家列表。更细粒度地，可以为每个物品对象加锁。
服务器运行一段时间后，响应变慢，最终内存溢出（OOM）	1.内存泄漏：玩家下线后，其对象仍被`World`中的某个集合引用（如未从在线列表或房间玩家列表中移除）。 2.资源未释放：数据库连接、文件流未关闭。 3.对象无限创建：如每次命令都创建大量临时对象。	1. 使用`jmap -histo:live <pid>`或VisualVM的堆Dump功能，分析内存中占比最高的对象类型。重点检查`Player`、`Channel`对象的数量是否与在线玩家数匹配。 2. 确保所有`Closeable`资源都在`finally`块或try-with-resources中关闭。 3. 对于频繁创建的简单对象（如命令解析的字符串数组），考虑对象池化或重用。
使用JSON序列化保存玩家数据时，出现循环引用错误（StackOverflowError）	`Player`对象持有`Room`引用，`Room`对象又持有该`Player`引用（在玩家列表中），形成循环。Jackson序列化时会陷入无限递归。	1.使用`@JsonIgnore`注解：在`Player`类的`getCurrentRoom()`方法或字段上添加`@JsonIgnore`，序列化时忽略此属性。加载时再根据`roomId`重新关联。 2.使用`@JsonManagedReference`和`@JsonBackReference`：在父子关系双方进行注解，但管理起来稍复杂。方案1更清晰实用。
战斗逻辑中，怪物反击导致服务器卡死	怪物反击的逻辑可能直接在当前线程中执行了耗时操作或死循环。	将战斗的每一回合结算（包括怪物AI决策）也提交到业务线程池中执行，确保不阻塞命令处理的主线程。设计战斗状态机，避免逻辑错误导致的无限循环。

性能调优心得：

Netty参数调优：SO_BACKLOG指定了连接请求队列长度，在预期高并发时可适当调大（如1024）。childOption(ChannelOption.TCP_NODELAY, true)可以禁用Nagle算法，减少小数据包的延迟，对于交互频繁的MUD游戏有益。
线程池配置：业务线程池的大小并非越大越好。通常设置为CPU核心数 * 2是一个不错的起点。需要通过压测找到最佳值。可以使用ThreadPoolExecutor并设置合适的队列（如LinkedBlockingQueue）和拒绝策略。
对象复用：对于频繁创建的Command对象，可以考虑使用享元模式或静态实例。对于字符串拼接，在热点代码中使用StringBuilder。
GC优化：如果观察到频繁的Full GC，可以考虑调整JVM堆参数（-Xms,-Xmx），并选择更适合响应式应用的垃圾收集器，如G1。

完成这样一个Java MUD项目，其价值远超一个课程设计的分数。它迫使你将书本上离散的知识点——网络、线程、IO、集合、设计模式、序列化——串联成一个有机的整体。你会在调试并发bug时深刻理解线程安全，在设计世界模型时体会面向对象的精髓，在解决性能瓶颈时学会权衡与取舍。这份源码和实战经验，无论是在面试中展示，还是作为个人技术成长的里程碑，都极具分量。最后一个小建议，务必为你的项目编写清晰的README文档，说明如何编译、运行、以及基本的游戏命令，这体现了你的工程素养，也能让评审老师或未来的面试官更快地看到你的成果。

本文还有配套的精品资源，点击获取