Google Antigravity 入门：Agent 优先的未来开发范式

欢迎来到 Antigravity 的深度教程！这是 Google 推出的一个免费、实验性的 Agent 优先开发平台。如果你想一步步地跟着操作，不妨去看看 Codelabs 版本，它现在分为两个部分：

插一句，我每两周会发布一期时事通讯，总结你需要了解的关键 Google Cloud Platform 新闻和公告。如果你感兴趣，现在就订阅吧。

博文更新日志：

2025年12月18日:

新增 Antigravity 对 MCP 服务器的支持。 2025年11月28日:

讲解如何更好地阅读本教程。

Antigravity 中的工作流（Workflows）和规则（Rules）。

Agent 安全性：允许列表（Allow List）、拒绝列表（Deny List）和浏览器允许列表。 2025年11月20日: 初始版本。

Antigravity 究竟是啥？我认为，你可以把它看作是一个全新的 Agent 驱动的开发平台，它将传统 IDE 进化成了以 Agent 为中心的体验。它和那些仅仅能帮你自动补全代码行的传统编码助手可不一样，Antigravity 提供了一个“任务控制”中心，帮你管理那些能自主规划、编码、甚至上网搜索的 Agent，它们会帮你把项目构建起来。

在我看来，Antigravity 的设计理念非常清晰：Agent 优先。这意味着它把 AI 视为一个能自主规划、执行、验证甚至迭代复杂工程任务的独立行动者，而非仅仅一个简单的代码助手。我们人类开发者需要做的干预，会少得多。

那在这个新环境里，我们开发者的角色又是什么呢？我个人认为，你的角色从填写代码片段、编辑代码，转变为一个“架构师”或“管理者”，负责编排一群数字 Agent 来完成任务。别担心，如果你想修改代码，还是有编辑器视图可以用。

不过，我们来深入理解一下“架构师”或“管理者”的含义。从传统的 IDE 转向一个让你能指挥数字 Agent 工作队的环境，到底意味着什么？下面这张图直观地对比了传统 IDE 的工作流程（左侧，用户直接与代码交互）和 Antigravity 的 Agent 驱动工作流程（右侧，用户通过管理器界面指挥自治 Agent）。

Antigravity 介绍与本教程导览

为了让你能充分利用本教程，我建议你按照以下步骤来：

设置与导航：这一部分你肯定得先完成，它会教你安装 Antigravity，推荐的配置，然后理解它的核心概念和关键导航功能。

用例实践：搞定基础后，你可以试几个当下就能用的用例，比如网站生成、动态 Web 应用开发、外部新闻聚合任务等等。

到这儿，你应该对 Antigravity 有个不错的认识了。我鼓励你尝试用自己的提示词和任务，让它来帮你完成。

Antigravity 自定义：你可能开始思考，如何让 Antigravity 尊重你的编码规范和指导方针，或者如何创建一套可重复的指令，通过一个简单的命令就能调用。这部分会介绍规则（Rules）和工作流（Workflows），它们是你给 Antigravity Agent 的指令，告诉它该怎么做。我们会提供多个例子帮你理解。

Agent 安全加固：Antigravity Agent 会根据你的任务去执行各种终端/shell 命令。你可能希望某些命令被禁止，或者需要你的明确许可才能执行，而另一些则可以自由运行。这部分将介绍如何在 Antigravity 中配置允许列表（Allow List）和拒绝列表（Deny List）。

注意：我们会随着 Antigravity 的新发现和有趣用法，持续更新本教程。

关键资源

我先在这里列出一些重要的参考资料，方便你查阅当前（截止 2025 年 11 月 19 日）可用的 Antigravity 官方文档：

官方网站：https://antigravity.google/
文档：https://antigravity.google/docs
用例：https://antigravity.google/use-cases
下载：https://antigravity.google/download
Google Antigravity 的 YouTube 频道：https://www.youtube.com/@googleantigravity

安装 Antigravity

我们先从安装 Antigravity 开始。目前，这个产品处于预览阶段，你可以用你的个人 Gmail 账号来体验。

点吉下载页面，然后选择适合你操作系统的版本：

我安装的是 MacOS 版本，后续我描述的步骤也主要基于这个版本。

如果你想在 ChromeOS 甚至 WSL (Windows Subsystem for Linux) 上安装 Linux 版本，这里有几篇博文可能会帮到你：

在 WSL 中使用 Google Antigravity —— 作者：Dazbo (Darren Lester)

在 ChromeOS / ChromeOS Flex 上运行 Antigravity —— 作者：xbill

设置 Antigravity

启动安装程序，然后在你的机器上完成安装。安装好后，启动 Antigravity 应用。你会看到一个类似下面的界面：

点吉“下一步”。接着会弹出一个选项，问你是否要从现有的 VS Code 或 Cursor 设置中导入。我们这里就从头开始吧。

下一个屏幕是选择主题类型。我通常喜欢深色主题，但你可以根据自己的喜好来选。

接下来的屏幕非常重要。它展示了 Antigravity 在 Agent 行为方面的灵活性。

我们来详细看看这些选项，记住，这些设置不是一成不变的，你随时都可以修改，甚至在与 Agent 交互的过程中也能调整。

在深入选项之前，我们先看对话框右侧的两个具体属性：

终端执行策略（Terminal execution policy）：这涉及到 Agent 在你的终端中执行命令（应用程序/工具）的能力。这里有三个选项：

关闭（Off）：绝不自动执行终端命令（除了可配置的允许列表中的命令）。
自动（Auto）：Agent 会判断是否自动执行某个终端命令。如果需要你的许可，它会决定并向你征求。
极速（Turbo）：总是自动执行终端命令（除了可配置的拒绝列表中的命令）。

审查策略（Review policy）：当 Agent 执行任务时，它会创建各种工件（任务计划、实施计划等）。审查策略就是让你决定谁来定意这些工件是否需要审查。你是想每次都审查，还是让 Agent 自己决定？相应的，这里也有三个选项：

总是进行（Always Proceed）：Agent 从不请求审查。
Agent 决定（Agent Decides）：Agent 会决定何时请求审查。
请求审查（Request Review）：Agent 总是请求审查。

现在我们理解了这些，上面屏幕上的四个选项其实就是这两种策略的预设组合，其中三个是固定组合，第四个是完全自定义。这四个选项的存在，是为了让你能灵活控制 Agent 在终端执行命令和提交工件审查的自主程度。

这四个选项是：

Agent 驱动开发（Agent-driven development）
Agent 辅助开发（Agent-assisted development）
审查驱动开发（Review-driven development）
自定义配置（Custom configuration）

“Agent 辅助开发”选项在我看来是一个不错的平衡点，也是推荐的选项，因为它允许 Agent 自己做决策，并在需要时再回来征求用户的批准。

所以，请选择你的偏好，目前来说，我们还是先遵循推荐的做法。

下一步是配置编辑器（Editor）。选择你喜欢的偏好设置。

前面提到过，Antigravity 目前处于预览模式，如果你有个人 Gmail 账号就可以免费使用。所以现在用你的账号登录吧。这会打开浏览器让你完成登录。

成功认证后，你会看到一条类似下面的消息，然后它会把你导回 Antigravity 应用。跟着流程走就行。

最后一步，和大多数应用一样，是服务条款。你可以选择是否同意，然后点击“下一步”。

到这里，你就来到了 Antigravity 准备好和你协作的关键时刻了。

我们开始吧。

Agent 管理器（Agent Manager）

Antigravity 以开源的 Visual Studio Code (VS Code) 为基础，但它彻底改变了用户体验，将 Agent 管理放在了文本编辑之上。界面被分成了两个截然不同的主窗口：**编辑器（Editor）**和 Agent 管理器（Agent Manager）。这种职责分离，正反映了个人贡献与工程管理之间的区别。

Agent 管理器视图：任务控制中心

通常情况下，当你启动 Antigravity 时，最先看到的不是文件树，而是 Agent 管理器，就像下面这张图：

这个界面就扮演着任务控制中心的角色。它专为高层级的编排设计，允许开发者在不同的工作区或任务中，同时启动、监控并与多个 Agent 异步交互。

在这个视图里，开发者更像是一位架构师。他们定义高层级的目标，例如：

重构认证模块
更新依赖树
为计费 API 生成测试套件

正如上图所示，每一个请求都会启动一个专用的 Agent 实例。用户界面会以可视化的方式展示这些并行工作流，包括每个 Agent 的状态、它们生成的工件（Artifacts）（计划、结果、差异）以及任何等待人类批准的请求。

这种架构解决了以前 IDE 中更多是聊天机器人体验的局限性，那些体验是线性和同步的。在传统的聊天界面中，开发者必须等待 AI 完成代码生成后才能问下一个问题。但在 Antigravity 的管理器视图中，一个开发者可以同时派遣五个不同的 Agent 去处理五个不同的 Bug，这能大大提高工作效率。

如果你点击上图中的“下一步”，你就可以选择打开一个工作区。

你可以把“工作区”理解成你在 VS Code 里认识的那个概念，这样就行了。所以，我们可以通过点击按钮，然后选择一个本地文件夹来开始。在我这里，我选了我家目录下一个叫 my-agy-projects 的文件夹。你当然也可以选择一个完全不同的文件夹。

值得一提的是，你可以完全跳过这一步，随时在后续打开一个工作区。

完成这一步后，你就会进入 Agent 管理器窗口，它看起来是这样子：

你会发现，应用立刻就准备好在选定的工作区文件夹 (my-agy-projects) 中开始一段新对话。值得注意的是，你可以利用你使用其他 AI 应用（如 Cursor, Gemini CLI）的经验，通过 @ 等方式加入额外的上下文来给出提示。

看看“规划（Planning）”和“模型选择（Model Selection）”这两个下拉菜单吧。“模型选择”下拉菜单允许你从当前可用的模型中选择一个，供你的 Agent 使用。列表如下：

同样，我们发现 Agent 默认处于 规划（Planning） 模式。但我们也可以选择 快速（Fast） 模式。

我们来看看文档对此是怎么说的：

规划（Planning）：Agent 可以在执行任务前先做规划。适用于深度研究、复杂任务或协作工作。在这种模式下，Agent 会将工作组织成任务组，生成工件，并采取其他步骤来彻底研究、思考并规划其工作，以获得最佳质量。你会看到更多的输出信息。
快速（Fast）：Agent 会直接执行任务。适用于可以更快完成的简单任务，例如重命名变量、启动几个 bash 命令或进行其他更小、更局部的任务。这在速度是重要因素，且任务足够简单、质量担忧较低时很有用。

如果你熟悉 Agent 中的“思考预算”及类似术语，这你可以理解为控制 Agent 思考能力的方式，直接影响其思考预算。我们暂时使用默认设置，但要记住，在发布时，Gemini 3 Pro 模型对每个人的可用配额是有限的，所以如果你用完了免费配额，可能会收到相应的提示。

现在我们花点时间来了解一下 Agent 管理器窗口，搞清楚一些基本构成，以及如何在 Antigravity 中进行导航等等。Agent 管理器窗口如下所示：

请参考上图中的数字：

收件箱（Inbox）：可以把它想象成一个地方，用来追踪你所有的对话。当你派遣 Agent 去执行任务时，它们会出现在收件箱里。你点吉收件箱，就能看到所有当前对话的列表。点吉任何一个对话，就能看到所有已交换的消息、任务状态、Agent 生成了什么，甚至它是否在等待你批准某项任务。这是回溯之前工作任务的好方法。一个非常方便的功能。
开始对话（Start Conversation）：点吉这里可以开始一段新对话。它会直接带你到那个写着“问点什么（Ask anything）”的输入框。
工作区（Workspaces）：我们前面提过工作区，你可以跨任何工作区工作。你随时可以添加更多工作区，并在开始对话时选择任何一个工作区。
游乐场（Playground）：这是一个非常棒的功能，你可以直接和 Agent 开始对话，然后如果你想把这个对话转换成一个工作区，对文件等有更严格的控制，那就可以。把它想象成一个草稿区。
编辑器视图（Editor View）：目前我们还在 Agent 管理器视图。如果你愿意，随时可以切换到编辑器视图。在那里，你会看到你的工作区文件夹和任何生成的文件。你可以直接编辑文件，甚至在编辑器中提供行内指导和命令，让 Agent 根据你修改的建议/指令进行操作或更改。我们会在后续章节详细介绍编辑器视图。
浏览器（Browser）：最后，我们来到了 Antigravity 众多强大功能中的一个显著亮点，那就是它与 Chrome 浏览器的紧密集成。接下来我们开始设置浏览器吧。

设置 Antigravity 浏览器

根据文档说明，当 Agent 需要与浏览器交互时，它会调用一个浏览器子 Agent 来处理手头的任务。这个浏览器子 Agent 运行的模型是专门针对 Antigravity 管理的浏览器中打开的页面进行操作的，这与你为主 Agent 选择的模型不同。

这个子 Agent 可以使用各种工具来控制你的浏览器，包括点击、滚动、输入、读取控制台日志等等。它还可以通过 DOM 捕获、截图或 Markdown 解析来读取你打开的页面，甚至录制视频。

这意味着我们需要启动并安装 Antigravity 浏览器扩展。我们不妨在游乐场中开始一段对话，跟着步骤来操作。

选择游乐场，然后给 Agent 如下任务：

go to antigravity.google

提交任务。你会看到 Agent 正在分析任务，你也可以查看它的思考过程。某个时候，它会正确地继续，并提到需要设置浏览器 Agent，如下所示。点吉 Setup。

这会打开浏览器，并显示一条消息，提示你安装扩展程序，如下所示：

继续操作，你会被引导到 Chrome 扩展商店，然后就可以安装了。

成功安装扩展后，Antigravity Agent 就会开始工作，并提示你允许它执行任务。你会看到打开的浏览器窗口有一些活动：

切换回 Agent 管理器，你应该会看到以下内容：

这正是我们预期的结果，因为我们让 Agent 访问 antigravity.google 网站。给予它权限后，你会发现网站已安全导航到，如下所示：

检查工件（Artifacts）

现在，有趣的部分来了。一旦 Agent 完成工作，你应该能看到它全部的工作成果。这就是“工件”的概念，它是你建立信任的基础，能帮你了解你计划了什么工作、目前做了什么、以及如何验证了这些工作。

工件解决了**“信任鸿沟”**。以前，当 Agent 声称“我修复了 Bug”时，开发者不得不通过阅读代码来验证。而在 Antigravity 中，Agent 会生成工件来证明它确实完成了。

Antigravity 会根据任务侧重生成关键工件。这可以包括任务计划（Task plan）、实施计划（Implementation Plan），以及最终的演练计划（Walkthrough plan，附带验证）。这些计划中应该包含以下内容：

任务列表与计划：在编写代码之前，Agent 会生成一个结构化的计划。用户可以审查、编辑并批准这个计划。
代码差异：标准化的差异视图，准确显示哪些代码行会发生变化。
屏幕截图：Agent 会捕获更改前后的 UI 状态。
浏览器录屏：对于动态交互（比如：“点击登录按钮，等待加载动画，验证仪表盘是否加载成功”），Agent 会录制其会话视频。开发者可以观看此视频，验证功能需求是否满足，而无需自己运行应用程序。
测试结果：Agent 生成并执行的通过/失败测试的结构化日志。

在 Agent 管理器视图的右上方，“审查更改”旁边，你应该能看到一个按钮，用来切换工件显示，如果已切换开启，你就能看到生成的工件列表：

你应该会看到工件视图，如下所示。在我们这个例子中，我们指示 Agent 访问 antigravity.google 页面，因此它捕获了截图，并创建了相应的视频等。

开发者可以通过“Google 文档式评论”与这些工件交互。你可以选择一个特定的操作或任务，提供你希望其执行的命令，然后提交给 Agent。Agent 会接收到这个反馈，并相应地进行迭代。你可以把它想象成使用交互式 Google Docs，你给作者提供反馈，然后作者根据反馈进行修改。

回顾收件箱（Inbox）

如果你已经和 Agent 进行了几次对话，现在不妨看看 Agent 管理器窗口中的“收件箱”。这里会显示你所有的对话。点吉任何一个对话，就能查看该对话的历史记录、生成的工件等详细信息。在我们这个例子中，第一次对话运行后，我们的收件箱就显示了这条对话，如下所示：

点吉该对话，将提供详细信息：

你也可以从这里继续对话。

编辑器（Editor）

编辑器保留了 VS Code 的熟悉感，这保证了经验丰富的开发者能够快速上手。它包含了标准的文件浏览器、语法高亮和扩展生态系统。

你可以点击 Agent 管理器右上方的 Open Editor 按钮，进入编辑器。

编辑器增强了“Agent 感知”能力：

行内命令：编辑器支持随心所欲的编码和行内指令，用户可以高亮代码并指示 Agent “让这部分代码更高效”或“添加注释解释这段逻辑”。
Agent 侧边栏：使用编辑器右侧的面板直接与 Agent 交互。你可以从这里开启新的对话，或者直接给出指令让它修改你的代码。

当我们后续通过一些 Web 开发的用例来让 Agent 创建多个代码文件时，我们就可以看看编辑器，查看文件、进行修改，并直接从这里与 Agent 交互。

在编辑器模式和 Agent 模式之间切换

请记住，Antigravity 有一个明确的理念：编辑器和 Agent 管理器是两个独立的窗口，并且两者都有其明确的需求。你可以在两者之间进行切换，无论是通过在编辑器中点击右上角的 Open Agent Manager 按钮，还是在 Agent 管理器中点击右上角的 Open Editor 按钮。

或者，你也可以使用以下键盘快捷键在两种模式之间切换：Cmd + E。

用例

现在我们对产品有了基本了解，接下来让我们通过几个用例来实际看看它的表现。需要注意的是，Antigravity 是一个 Agent 优先的平台。这意味着在大多数情况下，我们只需向 Agent 提供指令，然后 Agent 就会自主地去完成任务，在需要时请求权限，生成工件，并在任务完成后通知我们。因此，在下面的每个用例中，我们无法展示 Agent 对话的每一个输出。我们将分享指令和一些必要的截图，但你的结果可能会略有不同。

我们将涵盖的用例包括自动化一些外部网站的任务、为一个项目生成和验证单元测试，以及完整的网站开发。开始吧！

新闻亮点聚合

这是一个简单的用例，但它可以作为基础，让你学会如何利用网络浏览器访问网站、提取信息、执行一些操作，然后将数据返回给用户。

在这个案例中，我们将访问 Google 新闻网站并从中提取一些信息。你也可以轻松尝试自己选择的网站，看看效果如何。

确保你处于 Agent 管理器中，并且已选择游乐场，如下所示：

然后给出以下指令：

这会启动 Agent 进程，它会判断需要启动浏览器等。你应该密切关注它的思考过程，看看 Agent 是如何工作的。如果一切顺利，它应该会启动 Antigravity 浏览器并访问网站，如下所示。网站周围的蓝色边框表明 Agent 正在控制浏览器并导航网站以获取信息。

一旦它完成工作，你应该也会看到工件被生成，如下所示：

下面是 Agent 执行的一个示例：

请注意，左侧是我们 Agent 的思考过程。你还可以滚动查看这些思考点，并播放和查看其他数据。

尝试一下

理解了这个之后，你可以选择一个你喜欢的网站，让 Agent 从中获取/总结一些数据。试试一些你知道有仪表盘和图表的网站，然后让它提取一些值。
尝试以下提示词：Visit https://docs.cloud.google.com/release-notes and get me a summary of the release notes, categorized by product. (访问 https://docs.cloud.google.com/release-notes 并为我总结发布说明，按产品分类。)

使用 Python + Flask 生成动态网站

现在我们来生成一个完整的 Web 应用程序。我们要创建的这个 Web 应用，是一个为期一天的技术会议信息网站，其中有多个演讲者全天进行演讲。

再次确保你位于 Agent 管理器中，并且已选择游乐场。

给出以下提示词：

I would like to generate a website that is a 1-day technical conference informational site.
The website should have the following functionality:
1. A home page that shows the current date, location, schedule and time table.
2. The 1-day event is a list of 8 talks in total.
3. Each talk has 1 or 2 max. speakers.
4. A talk has a ID, Title, Speakers, Category (1 or 2), Description and time of the talk.
5. Each speaker has a First Name, Last Name and LinkedIn url.
6. Allow for users to search by category, speaker, title.
7. Give a lunch break of 60 minutes.
8. Use dummy data for events and speakers, come up with a schedule, the event is about Google Cloud Technologies.
9. Tech Stack: Python and Flask framework on server side. Front-end is basic HTML, CSS and JavaScript.
10. Test out the site on your own for all functionality and provide a detailed README on how to setup, run and make any further changes.
11. Launch the web application for me to review.

你可以通过给出上面的提示词来开始对话。Agent 在执行任务时，会着手创建以下工件：

任务工件（Task Artifact）
实施工件（Implementation Artifact）
演练工件（Walkthrough Artifact）

下面给出的任务工件是 Agent 根据你给出的任务初步分析后得出的任务序列。下面是一个执行过程中的截图示例：

然后你可以点吉**实施计划（Implementation Plan）**工件。下面是截图示例：

最后，你将看到**演练（Walkthrough）**工件。它包含了 Agent 完成的所有工作，如下所示：

请注意，它已经启动了服务器并提供了 URL，我点击后就看到了应用程序，下面是一个截图示例：

如果我切换到编辑器，你会发现屏幕上包含了生成 Python Flask 应用程序的文件夹。你还会注意到，Agent 模式已在右侧标记，你也可以在那里继续对话。

现在，假设我们想给活动再增加几个演讲。我们可以在编辑器里，然后在 Agent 面板中给出一个指令，比如 Add two more talks to the schedule. (再给日程表加两个演讲)。

这会导致 Agent 分析需求，更新任务，实施计划，然后再次验证更新后的功能。下面是一个对话示例：

如果你愿意，可以切换回 Agent 管理器。这个过程应该能帮助你理解从 Agent 管理器切换到编辑器，并相应进行更改等等。

注意： 在执行此任务时，Agent 尝试在端口 5000 上启动 Flask 服务器，但该端口在当前机器上已被占用。它不断尝试下一个可用端口，直到决定使用 8080 并成功启动服务器。

尝试一下

给应用程序添加更多你想要的功能。把细节告诉 Agent，然后观察它是如何先修改任务列表，再修改实施计划等等。
让 Agent 为应用程序生成一个 README 或更多文档。

生成一个简单的效率应用

我们现在要生成一个简单的番茄工作法计时器 Web 应用程序。

确保你处于 Agent 管理器中，并且已选择游乐场。给出以下提示词：

Create a productivity app that features a Pomodoro timer. Give a calm and aesthetic look to the application. (创建一个具有番茄工作法计时器功能的效率应用。让应用程序看起来平静而美观。)

注意它是如何创建任务列表、实施计划，然后着手执行的。请持续关注流程，有时它可能会提示你进行审查。下面是一个运行示例。

在这个例子中，它也应该会启动 Antigravity 浏览器，进行自己的测试，然后确认测试成功。它生成的一个**媒体工件（Media Artifact）**包含了其验证过程的视频。这是一个很好的方式来查看它测试了什么。我还建议了一些样式更改，因为之前的更改没有生效，而它也成功完成了。

最终的应用看起来像下面这样，我觉得还挺不错的。

我们再给应用程序添加一个漂亮的计时器图片怎么样？我们只需要发出一个后续指令，如下所示：

Add an image to the application that displays a timer. (给应用程序添加一张显示计时器的图片。)

这导致 Agent 在任务工件中增加了一个新任务：

然后它在执行任务时生成了一张图片：

最后，应用程序有了我们请求的图片：

尝试一下

注意应用程序中沙漏图标的背景不是透明的。试着告诉 Agent 让它变得透明。
试试看生成你喜欢的任何应用程序，并尝试不同的样式、图片，提出更改要求等等。

生成单元测试、模拟桩（Mock Stubs）并验证测试

我们在这里要尝试的最后一个用例是，为我们已有的特定代码文件生成单元测试，并让 Agent 执行测试和验证它们。

为此，我们将有一个工作区，其中包含一个 Python 文件，如下所示：

from typing import Dict

# --- Custom Exceptions ---
class InventoryShortageError(Exception):
    """Raised when there is not enough item stock."""
    pass

class PaymentFailedError(Exception):
    """Raised when the payment gateway rejects the transaction."""
    pass

class InvalidOrderError(Exception):
    """Raised when the order violates business rules."""
    pass

# --- External Service Interfaces (To be Mocked) ---
class InventoryService:
    def get_stock(self, product_id: str) -> int:
        """Connects to DB to check stock."""
        raise NotImplementedError("Real connection required")

    def decrement_stock(self, product_id: str, quantity: int):
        """Connects to DB to reduce stock."""
        raise NotImplementedError("Real connection required")

class PaymentGateway:
    def charge(self, amount: float, currency: str) -> bool:
        """Connects to Stripe/PayPal."""
        raise NotImplementedError("Real connection required")

# --- Main Business Logic ---
class Order:
    def __init__(self,
                 inventory_service: InventoryService,
                 payment_gateway: PaymentGateway,
                 customer_email: str,
                 is_vip: bool = False):
        
        self.inventory = inventory_service
        self.payment = payment_gateway
        self.customer_email = customer_email
        self.is_vip = is_vip
        self.items: Dict[str, Dict] = {} # {product_id: {'price': float, 'qty': int}}
        self.is_paid = False
        self.status = "DRAFT"

    def add_item(self, product_id: str, price: float, quantity: int = 1):
        """Adds items to the cart. Rejects invalid prices or quantities."""
        if price < 0:
            raise ValueError("Price cannot be negative")
        if quantity <= 0:
            raise ValueError("Quantity must be greater than zero")

        if product_id in self.items:
            self.items[product_id]['qty'] += quantity
        else:
            self.items[product_id] = {'price': price, 'qty': quantity}

    def remove_item(self, product_id: str):
        """Removes an item entirely from the cart."""
        if product_id in self.items:
            del self.items[product_id]

    @property
    def total_price(self) -> float:
        """Calculates raw total before discounts."""
        return sum(item['price'] * item['qty'] for item in self.items.values())

    def apply_discount(self) -> float:
        """
        Applies business logic:
        1. VIPs get flat 20% off.
        2. Regulars get 10% off if total > 100.
        3. No discount otherwise.
        """
        total = self.total_price
        
        if self.is_vip:
            return round(total * 0.8, 2)
        elif total > 100:
            return round(total * 0.9, 2)
        
        return round(total, 2)

    def checkout(self):
        """
        Orchestrates the checkout process:
        1. Validates cart is not empty.
        2. Checks stock for all items.
        3. Calculates final price.
        4. Charges payment.
        5. Updates inventory.
        """
        if not self.items:
            raise InvalidOrderError("Cannot checkout an empty cart")

        # 1. Check Inventory Logic
        for product_id, data in self.items.items():
            available_stock = self.inventory.get_stock(product_id)
            if available_stock < data['qty']:
                raise InventoryShortageError(f"Not enough stock for {product_id}")

        # 2. Calculate Final Price
        final_amount = self.apply_discount()

        # 3. Process Payment
        try:
            success = self.payment.charge(final_amount, "USD")
            if not success:
                raise PaymentFailedError("Transaction declined by gateway")
        except Exception as e:
            # Catching generic network errors from the gateway
            raise PaymentFailedError(f"Payment gateway error: {str(e)}")

        # 4. Decrement Stock (Only occurs if payment succeeded)
        for product_id, data in self.items.items():
            self.inventory.decrement_stock(product_id, data['qty'])

        self.is_paid = True
        self.status = "COMPLETED"
        
        return {"status": "success", "charged_amount": final_amount}

确保你将上面的 Python 文件本地保存在一个文件夹中，并将其作为工作区加载到 Antigravity 中。

这是一个简单的订单服务，其 checkout 函数包含以下关键功能：

验证购物车是否为空。
检查所有商品的库存。
计算最终价格。
处理付款。
更新库存。

我们将给 Agent 分配生成单元测试用例、提供模拟实现并执行测试以确保它们成功的任务。

我们将打开我们特定的工作区文件夹，你会注意到我们现在也可以使用 @ 符号来引用文件。例如，我们可以这样做：

它会给出一些关于这个文件的解释：

我们可以通过以下提示词，让它生成一个更好的可视化效果：

Can you visually show this class for better understanding (你能否以可视化的方式展示这个类，以便更好地理解)

然后我们得到以下输出：

下一步是生成单元测试并让 Agent 进行测试。我给出以下提示词：

generate unit tests for this module and test it out with mock implementations. (为这个模块生成单元测试，并使用模拟实现进行测试。)

它生成了以下任务工件并开始执行任务：

你还可以查看它运行的测试的详细信息：

它生成的文件之一也是测试文件。下面是其截图：

尝试一下

拿出你自己的代码，看看你能让 Agent 做些什么，从添加更多功能到重构代码的某些部分。

在 Antigravity 中配置 MCP 服务器

模型上下文协议（MCP）已经成为一项通用标准，它能让你将 AI 应用程序连接到外部工具，从而将结果基于你的自有数据。在 Antigravity 的语境下，模型上下文协议的支持，弥合了编辑器和外部世界之间的鸿沟。正如文档所述，“它允许安全地连接到你的本地工具、数据库和外部服务。这种集成让 AI 获得了超越编辑器中打开文件的实时上下文”。

当你向 Agent 提供提示时，它会判断是否需要调用适当的 MCP 服务器及其工具。Antigravity 内置了一系列你可以直接通过几次点击安装的 MCP 服务器，你也可以手动配置自己的 MCP 服务器（本地或远程）。我们将分别看看这两种选项。

支持的 MCP 服务器

Antigravity 支持多种流行的 MCP 服务器。这个列表很可能会不断增加。要开始使用，请确保你处于 编辑器 模式。在左上方，点击“…”选项并选择 MCP 服务器，如下所示：

这会弹出 MCP 商店，你会看到一个庞大的已支持服务器列表，如下所示：

你可以选择任何你感兴趣的服务器。一旦你选中它，就会弹出一个对话框，其中包含 MCP 服务器的详细信息和一个安装按钮。

我们来安装 Firebase MCP 服务器。当我从 MCP 商店中选择它时，它会显示 Firebase MCP 服务器的详细信息，如下所示：

点吉安装按钮。如果需要任何其他详细信息，它会提示你；如果不需要，它会简单地在 Antigravity 中配置 MCP 服务器，并显示其已启用。

然后你可以点击**配置（Configure）链接查看是否需要任何配置，或者点击工具（Tools）**链接查看此 MCP 服务器支持的工具。下面显示了 Firebase MCP 服务器支持的工具示例列表：

注意，你也可以通过每个工具旁边的开关按钮来单独启用它们。

现在，如果你回到 MCP 商店，然后点吉**管理 MCP 服务器（Manage MCP Servers）**按钮：

你会看到已配置的 MCP 服务器以列表形式显示，你可以点击 MCP 服务器查看工具列表，但最重要的是，请看看顶部“刷新（Refresh）”按钮旁边的**查看原始配置（View raw config）**选项。

这会显示 mcp_config.json 文件，它位于 ~/.gemini/antigravity 文件夹中。如果你需要，也可以在这个文件中自行配置 MCP 服务器。我们会在接下来的部分中，配置 GitHub MCP 服务器时看到这一点，特别是它支持远程 MCP 服务器选项。

试着用适当的提示词调用你想要使用的特定工具。

设置远程 Github MCP 服务器

现在我们来设置一个远程 GitHub MCP 服务器。为此，你需要 GitHub 个人访问令牌（PAT），所以请确保你已将其保存在某处。

再次进入 编辑器 模式，然后点吉“…”选项，MCP 服务器，再从 MCP 商店对话框中，点吉管理 MCP 服务器按钮，如下所示：

这会列出当前已设置的 MCP 服务器。点吉顶部“刷新”按钮旁边的**查看原始配置（View raw config）**选项。这会打开 mcp_config.json 文件，你需要在 mcpServers 块内放置另一个对象。示例如下。你需要将 <YOUR_PAT> 替换为你的 GitHub 个人访问令牌值。

"remote-github": {
      "serverUrl": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer <YOUR_PAT>",
        "Content-Type": "application/json"
      }
    }

保存文件，然后点吉刷新。给它一些时间。你会看到我们配置的 remote-github 服务器现在已可用，并拥有 40 个工具，如下所示：

治理 Antigravity — 规则（Rules）和工作流（Workflows）

开发者需要他们的工具表现得一致。在标准的 LLM 聊天界面中，用户经常会重复相同的上下文：“我使用 Python 3.9”、“使用蛇形命名法”、“不要使用这个库”。

为了提高效率，我们希望我们的工具能够理解这些，遵循指导原则，并帮助我们提高效率，这样我们就不用一直重复这些话了。

Antigravity 通过双层自定义系统来解决这个问题：规则（Rules）和工作流（Workflows）。

工作流和规则可以在多个地方进行配置：

你可以进入编辑器窗口，在右下角你会看到 Antigravity - 设置。

点吉它，然后选择 自定义 → 管理。你将看到以下规则和工作流设置，如下所示：

或者，你也可以在编辑器窗口的 Agent 对话面板中，点击右上角的“…”按钮，如下所示：

然后点吉自定义，你将被引导到相同的规则和工作流设置页面。

理解规则（Rules）和作用域（Scopes）

规则是 Agent 的“系统指令”或不可变宪法。它们是被动的、持久的指导方针，Agent 在生成任何代码或计划之前必须考虑。它们不是由用户触发的；它们总是**“开启”**状态，因此，Agent 的输出将开始与开发者的意图保持一致。

规则在两个不同的作用域下工作，这允许一种类似于软件继承的控制层次结构：

全局规则（Global Rules）：这些规则适用于你在 Antigravity 中打开的所有项目。它们定义了你的个人编码理念或组织规范。

存储位置：~/.gemini/GEMINI.md。
用例： 设置特定语言的偏好（例如，“始终使用 TypeScript 而非 JavaScript”）、文档标准（“始终添加 docstrings”）或道德准则（“绝不生成硬编码的 API 密钥”）。

工作区规则（Workspace Rules）：这些规则特定于当前项目（工作区）。它们会覆盖或补充全局规则。

存储位置：你的工作区/.agent/rules/。
用例：项目特定的架构模式（例如，“数据库访问使用 Repository 模式”）、技术栈限制（例如，“样式使用 Tailwind CSS”）或遗留代码处理指令。

规则（Rules）示例

为了展示规则的多功能性，请尝试下面的一些规则，它们涵盖了从代码格式到前端偏好等多个方面。

规则 1：代码风格规则（PEP 8）

使用此规则可以确保所有生成的代码都符合你的 linting 标准，无需手动清理。

打开自定义设置： 点击右上角的“…”菜单，然后选择自定义（Customizations）。
添加工作区规则： 选择规则（Rules），然后点击**+工作区（+Workspace）**按钮。
定意规则： 将文件命名为 code-style-guide 并粘贴以下内容：

Code Style Guidelines

PEP 8 Compliance: All Python code must strictly adhere to PEP 8 standards.
Documentation: Every function and class must have a docstring explaining its purpose, arguments, and return values.
Type Hinting: Use Python type hints for all function arguments and return types.

测试方法：

打开一个新的聊天，然后问：Write a function to calculate the Fibonacci sequence. (编写一个计算斐波那契数列的函数。)
结果：Agent 会生成带有完整类型提示（例如，def fib(n: int) -> int:）和 docstring 的代码。

规则 2：模块化架构规则

使用此规则可以防止 Agent 将所有逻辑都堆在一个文件里。

添加工作区规则： 点击**+工作区**。
定意规则： 将文件命名为 architecture-guide 并粘贴以下内容：

Entry Point: main.py is for orchestration only. It should strictly call functions from other modules.

No Logic in Main: Do not define business logic functions inside main.py.
Modularity: Always create a new file (e.g., utils.py, feature_x.py) for new functionality and import it.

测试方法：

询问 Agent：Create a script that performs a binary search on a list of numbers. (创建一个脚本，对数字列表执行二分查找。)
结果： Agent 会创建一个 binary_search.py 来实现逻辑，并只更新 main.py 以导入并运行它。

规则 3：安全强制规则

使用此规则可以严格执行安全最佳实践。

添加工作区规则： 点击**+工作区**。
定意规则： 将文件命名为 security-mandates 并粘贴以下内容：

Security Non-Negotiables

No Hardcoded Secrets: NEVER output API keys, passwords, or tokens in code. Use os.getenv().
Input Validation: All user inputs (CLI args, HTTP requests) must be validated and sanitized.
Safe Imports: Do not use eval() or exec() under any circumstances.

测试方法：

询问 Agent：Write a script that connects to the database using the password ‘admin123’. (编写一个使用密码“admin123”连接数据库的脚本。)
结果： Agent 会拒绝硬编码密码，而是实现一个环境变量检查。

规则 4：健壮性协议（错误处理）

使用此规则可以防止代码脆弱，避免静默崩溃。

添加工作区规则： 点击**+工作区**。
定意规则： 将文件命名为 error-handling 并粘贴以下内容：

Error Handling Standards

No Bare Excepts: Never use except: without an exception type. Catch specific errors (e.g., except ValueError:).
Structured Logging: Do not use print(). Use the logging library for all outputs.
Fail Gracefully: Scripts should never crash with a stack trace visible to the user. Wrap main execution in a try/except block.

测试方法：

询问 Agent：Write a script to read a JSON file. (编写一个读取 JSON 文件的脚本。)
结果： Agent 会包含 import logging，设置一个日志记录器，并将文件读取包装在一个 try/except FileNotFoundError 块中。

规则 5：前端一致性规则

使用此规则可以强制执行特定的框架模式（例如，React & Tailwind）。

添加工作区规则： 点击**+工作区**。
定意规则： 将文件命名为 frontend-stack 并粘贴以下内容：

Frontend Stack Guidelines

Functional Components: All React components must be Functional Components using Hooks. Class components are forbidden.
Styling: Use Tailwind CSS utility classes. Do not use inline styles or separate CSS files.
Naming: Use PascalCase for component filenames (e.g., UserProfile.tsx).

测试方法：

询问 Agent：Create a button component. (创建一个按钮组件。)
结果： Agent 会生成 Button.tsx，使用 const Button = () =>... 并应用 Tailwind 类，例如 className="bg-blue-500..."。

规则 6：类型安全法令 使用此规则可在动态语言中强制执行严格类型。

添加工作区规则： 点击**+工作区**。
定意规则： 将文件命名为 type-safety 并粘贴以下内容：

Type Safety Rules

Strict Typing: All function signatures must have type annotations.
No Any: Avoid using Any type. Define data classes or interfaces for complex structures.
Return Types: Always specify the return type, even if it is None or void.
Test It: Ask the agent: "Create a function that processes a list of user dictionaries."
Result: Instead of generic Dicts, the agent likely defines a User TypedDict or dataclass and uses List[User] in the signature.

测试方法：

询问 Agent：Create a function that processes a list of user dictionaries. (创建一个处理用户字典列表的函数。)
结果： Agent 很可能会定义一个 User TypedDict 或数据类，而不是使用通用的 Dict，并在函数签名中使用 List[User]。

工作流（Workflows）

现在我们来谈谈工作流。虽然规则是被动约束，但工作流是主动的、由用户触发的程序。它们类似于“保存的提示”或“宏模”，包含了多步骤的意图。它们代表了重复性开发者任务的规范化。

工作流通过聊天界面中的斜杠 / 命令按需调用。当开发者输入 / 时，一个可用工作流的下拉菜单会出现，允许快速执行复杂、重复的任务。与规则一样，它们也存在于全局和工作区作用域（.agent/workflows/）。

工作流（Workflows）示例

为了说明工作流的强大功能，请尝试下面建议的一些工作流，它们涵盖了测试、文档、基础设施等多个方面。

工作流 1：“按需测试”工作流

当你想要严格测试刚构建的特定功能时，可以使用此工作流。

打开自定义设置： 导航到自定义 > 工作流。
添加工作区工作流： 点击**+工作区**。
定意工作流： 将文件命名为 generate-unit-tests 并粘贴以下内容：

Unit Test Generation Workflow

Trigger: When the user invokes this workflow. Instructions:

Analyze all Python files in the current active context.

For every file (e.g., utils.py), create a corresponding test file (e.g., test_utils.py).

Use the pytest framework.

Ensure every function has at least one positive test case and one edge case.

测试方法：

在 math_ops.py 中编写一些代码。在聊天中，输入 / 并选择 generate-unit-tests。Agent 会立即生成测试套件。

工作流 2：“文档冲刺”工作流

使用此工作流可以为你的项目自动生成全面的文档。

添加工作区工作流： 点击**+工作区**。
定意工作流： 将文件命名为 generate-project-docs 并粘贴以下内容：

Documentation Generator

Goal: Create a comprehensive README.md for the current project. Steps:

Scan the entire codebase to understand the project's purpose and dependencies.

Create or Update README.md with the following sections:

Project Title & Description

Installation: (e.g., pip install -r requirements.txt)

Usage: Provide code blocks showing how to run the main script.

Project Structure: A tree view of the files.

Ensure the tone is professional and concise.

测试方法：

打开一个凌乱的项目文件夹。输入 / 并选择 generate-project-docs。Agent 会读取你的文件并生成一个 README。

工作流 3：“重构与优化”工作流

将其用作“高级工程师”审查伙伴，以优化你的代码。

添加工作区工作流： 点击**+工作区**。
定意工作流： 将文件命名为 optimize-code 并粘贴以下内容：

Code Optimization Workflow

Goal: Review and optimize the open file. Instructions:

Analyze the time complexity (Big O) of the current functions.

Identify any nested loops that can be flattened or optimized.

Check for redundant variable assignments.

Output: Provide a refactored version of the code that improves performance, and explain why it is faster.

测试方法：

编写一个故意低效的脚本（例如，一个三重嵌套循环中的冒泡排序）。输入 / 并选择 optimize-code。Agent 会分析复杂性，解释低效之处，并使用更高效的算法或数据结构重写它。

工作流 4：“API 客户端生成器”工作流

使用此工作流可以为新的后端端点自洞生成一个前端服务。

添加工作区工作流： 点击**+工作区**。
定意工作流： 将文件命名为 generate-api-client 并粘贴以下内容：

API Client Generator

Goal: Create a TypeScript frontend service for the selected backend code. Steps:

Read the currently open backend file (e.g., Python FastAPI or Node Express).

Identify all API routes, methods (GET/POST), and required payload schemas.

Create a corresponding TypeScript file (e.g., api.ts).

Define TypeScript interfaces for all request and response bodies.

Write an async function for each endpoint using fetch or axios.

测试方法：

打开一个包含后端 API 路由的文件。输入 / 并选择 generate-api-client。Agent 会创建一个强类型的前端客户端，随时可用。

工作流 5：“Docker 化应用”工作流

使用此工作流可以立即容器化任何应用程序。

添加工作区工作流： 点击**+工作区**。
定意工作流： 将文件命名为 dockerize-app 并粘贴以下内容：

Dockerization Workflow

Goal: Containerize the current application. Steps:

Analyze the codebase to detect the language (Node, Python, Go) and dependencies (package.json, requirements.txt).

Create a Dockerfile optimized for production (use multi-stage builds if possible).

Create a .dockerignore file to exclude node_modules, .git, and .env.

Create a docker-compose.yml file if a database is detected in the code configuration.

测试方法：

打开一个 Python/Flask 或 Node/Express 项目。输入 / 并选择 dockerize-app。Agent 会生成所有这三个文件，让你的应用程序在几秒钟内具备云原生能力。

工作流 6：“数据库播种器”工作流

使用此工作流可以生成用于测试应用程序的虚拟数据。

添加工作区工作流： 点击**+工作区**。
定意工作流： 将文件命名为 seed-database 并粘贴以下内容：

Database Seeding Workflow

Goal: Create a script to populate the database with dummy data. Steps:

Analyze the database schema or ORM models (e.g., SQLAlchemy models, Prisma schema).

Identify relationships between tables (foreign keys).

Create a script (e.g., seed.py or seed.ts) that uses a faker library to generate 50 realistic records for each table.

Ensure records are inserted in the correct order to satisfy foreign key constraints.

测试方法：

打开一个带有定义好的数据库模式的项目。输入 / 并选择 seed-database。Agent 会编写一个脚本，你可以运行它来立即用测试用户、产品和订单填充你的应用程序。

工作流 7：“拉取请求草稿”工作流

使用此工作流可以自动自动化作提交代码的行政工作。

添加工作区工作流： 点击**+工作区**。
定意工作流： 将文件命名为 draft-pr 并粘贴以下内容：

PR Description Generator

Goal: Draft a professional Pull Request description based on recent changes. Steps:

Run git diff main (or the target branch) to see all changes made.

Summarize the changes into three sections:

What Changed: A bulleted list of technical changes.

Why: The reasoning behind the changes (infer from code or comments).

Testing: How these changes can be verified.

Format the output as a Markdown block ready to be pasted into GitHub/GitLab.

测试方法：

对你的代码进行一些更改。输入 / 并选择 draft-pr。Agent 会分析你的差异并为你的团队编写一份简洁专业的总结。

确保 Agent 安全 — 允许列表、拒绝列表和浏览器安全

赋予 AI Agent 访问你的终端和浏览器的权限是一把双刃剑。它虽然能实现自主调试和部署，但也为**提示注入（Prompt Injection）和数据泄露（Data Exfiltration）**打开了通道。

如果一个 Agent 可以运行 curl 命令，它就能把你的私钥发送到一个恶意服务器。Antigravity 通过围绕终端命令自动执行策略（Terminal Command Auto Execution）、**允许列表（Allow Lists）和拒绝列表（Deny Lists）**的细粒度权限系统来解决这个问题。

当你首次配置 Antigravity 时，或者通过设置菜单，你必须选择一个“终端命令自动执行”策略。此设置决定了 Agent 对 shell 命令的自主性。

你可以通过在右下角找到 Antigravity - 设置，然后选择 高级设置 来查看你当前的设置。你应该会看到 Agent 设置的“终端”部分，如下所示：

你可以看到当前“自动执行”设置为自动（Auto）。请记住这张表格，以便你将来想更改此设置时参考：

配置允许列表（白名单）

允许列表主要与**关闭（Off）**策略一起使用。它代表了一种积极的安全模型，意味着除非明确允许，否则一切都被禁止。这是最安全的配置。

分步配置

将“终端命令自动执行”设置设置为关闭（Off）。
通过点击其旁边的**添加（Add）按钮，在允许列表终端命令（Allow List Terminal Commands）**中添加以下命令。

ls -al
npm run test

测试允许列表：

询问 Agent：List the files in this directory (列出此目录中的文件)。
Agent 会自动运行 ls。
询问 Agent：Delete the <some file>. (删除 <某个文件>)。在我的例子中，我要求它删除我的 main.py 文件。
Agent 会尝试执行 rm <filepath>，但 Antigravity 会阻止它并强制进行用户审查，因为 rm 不在允许列表中。请看下面的行为，它会等待人工输入以允许操作。

配置拒绝列表（黑名单）

拒绝列表是极速（Turbo）（有时也包括自动（Auto））策略的保障。它代表了一种消极的安全模型，意味着除非明确禁止，否则一切都被允许。这依赖于开发者预见到所有可能的危险，这是一个有风险的提议，但它提供了最大速度。

分步配置

将“终端命令自动执行”设置设置为极速（Turbo）。
通过点击其旁边的**添加（Add）按钮，在拒绝列表终端命令（Deny List Terminal Commands）**中添加以下 2-3 个命令。

rm
del
rmdir
sudo
curl
wget
ssh

测试允许列表：

询问 Agent：Check the version of python (检查 python 版本)。
Agent 会自动运行 python --version。
询问 Agent：Download www.google.com home page. (下载 www.google.com 主页)。
Agent 会尝试执行 curl...。Antigravity 检测到 curl 在拒绝列表中，并阻止执行，提示你进行手动批准，如下所示：

浏览器安全

Antigravity 浏览网页的能力是一项超能力，但也是一个漏洞。Agent 访问一个被攻击的文档网站，可能会遭遇提示注入攻击。

为了防止这种情况，你可以为浏览器 Agent 实施浏览器 URL 允许列表（Browser URL Allowlist）。

你可以通过在右下角找到 Antigravity - 设置，然后选择 高级设置 来查看你当前的设置。你应该会看到浏览器设置部分的浏览器 URL 允许列表，如下所示：

点吉打开允许列表文件（Open Allowlist File），这会打开 HOME/.gemini/antigravity/browserAllowlist.txt 文件夹中的文件。示例如下：

你可以确保这里只输入受信任的域。

结语

恭喜你，你已经成功安装并了解了如何使用 Antigravity 这个 Agent 优先的开发平台。我们尝试的各种用例应该能帮助你将自己的需求代入其中，探索 Antigravity 如何与你协作完成它们。

除了这些用例，我们还探讨了如何让 Antigravity 采纳你自己的工作流和规则，确保其输出符合你的流程、指导方针和标准。

我们还深入研究了 Agent 安全，并确保通过允许列表、拒绝列表和适当的终端执行模式结合，Agent 可以在执行终端命令前向我们征求确认，而不是自行决定。

最后，我们谈到了确保理解浏览器安全，并配置它只访问受信任的网站。

参考文档

官方网站：https://antigravity.google/
文档：https://antigravity.google/docs
用例：https://antigravity.google/use-cases
下载：https://antigravity.google/download
Google Antigravity 的 YouTube 频道：https://www.youtube.com/@googleantigravity

Google Cloud Platform 技术更新

厌倦了在 Google Cloud 的更新中大海捞针？我的双周刊时事通讯会为你送上你必须知道的 Google Cloud Platform 关键新闻和公告。现在就订阅吧。

关于

关注我获取更多资讯

📢 公众号

💬 个人号