企业官网建设流程全解析

1. 为什么用 Cursor 而不是直接上 IntelliJ IDEA？——从 Java 开发者真实工作流说起

我第一次在团队内部演示 Cursor 配置 SpringBoot 项目时，有位做了十年后端的老同事盯着屏幕看了三分钟，最后问了一句：“这玩意儿真能替代 IDEA？它连 Maven 依赖图谱都画不出来，怎么 debug 多模块循环引用？”
这个问题问得特别准，也特别典型。它点出了当前很多 Java 工程师对 Cursor 的核心误解：把 Cursor 当成一个“轻量版 IDEA”来用，而不是把它当作一个“以 AI 为内核、专为现代 Java 工程流重构的智能协作终端”。

这不是一个功能多寡的问题，而是一个工作范式切换的问题。IDEA 是“你告诉它要做什么”，Cursor 是“它主动理解你在做什么，并提前补全你还没想到的下一步”。比如你在写一个@RestController类，刚敲完@GetMapping("/user/{id}")，Cursor 不仅会自动补全public ResponseEntity<User> getUser(@PathVariable Long id)方法签名，还会基于你项目里已有的UserMapper和UserService命名习惯，推测出你接下来大概率要注入UserService并调用findById(id)—— 它甚至会检查User实体类是否实现了Serializable，如果没实现，会在补全代码下方直接标出 Lombok 注解缺失的警告。这种“上下文感知型补全”，是传统 IDE 的索引机制根本做不到的。

这也解释了为什么大量搜索“cursor 配置 java 项目环境”的人，实际卡住的从来不是 JDK 或 Maven 的安装路径，而是环境配置完成后，AI 却无法理解你的项目结构、无法识别 Spring Boot 的自动装配逻辑、甚至把@Autowired标红报错。问题根源不在环境本身，而在 Cursor 对 Java 生态的理解深度，取决于你是否让它“真正看懂”你的项目。它不像 IDEA 那样开箱即用，但一旦喂养到位，它的响应速度、上下文连贯性和错误预判能力，会远超传统工具。

所以，这篇内容不叫“Cursor 安装教程”，而叫“让 Cursor 真正读懂你的 Java 项目”。我们不会从官网下载链接开始讲起，而是从你打开一个空文件夹、准备初始化一个 SpringBoot 项目的那一刻切入——告诉你每一步操作背后，Cursor 在“想什么”，以及你该给它什么信号，才能让它从“一个会写代码的聊天框”，变成你身边那个对 Spring 生态烂熟于心、能和你实时对线技术方案的资深搭档。关键词不是“cursor”或“java”，而是“上下文对齐”—— 这才是所有配置动作的终极目标。

2. JDK 配置：不是选版本，而是建立“类型系统信任链”

很多人以为 JDK 配置就是把JAVA_HOME指向一个目录，然后在 Cursor 设置里填个路径就完事了。实测下来，这是导致后续 70% 的 AI 补全失效、Lombok 报红、甚至mvn compile在终端里成功但在 Cursor 内置终端报错的根本原因。问题出在 Cursor 对 Java 类型系统的信任起点，必须和你的编译器、构建工具、乃至 JVM 运行时完全一致。这个一致性，不是靠路径字符串保证的，而是靠一套可验证的“信任链”。

2.1 为什么JAVA_HOME的值本身毫无意义？

先看一个真实案例：一位用户反馈，他在 macOS 上通过 Homebrew 安装了openjdk@17，echo $JAVA_HOME输出/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home，看起来天衣无缝。但在 Cursor 里新建一个Main.java，写List<String> list = new ArrayList<>();，ArrayList却被标红，提示 “Cannot resolve symbol ‘ArrayList’”。他反复检查路径，甚至重装 JDK，都没用。

真相是：Cursor 启动时读取的JAVA_HOME，只是它寻找javac编译器的起点。但它真正用来做语义分析（也就是理解ArrayList是什么）的，是javac自带的rt.jar（Java 9+ 是modules-java.base）里的字节码定义。而 Homebrew 安装的 OpenJDK，默认不包含完整的jmods模块集，尤其是java.base.jmod这个核心模块。Cursor 的语言服务器（LSP）在启动时尝试加载这些模块进行类型推导，加载失败，就退化为纯文本匹配，自然找不到ArrayList。

所以，第一步不是设置路径，而是验证 JDK 是否具备完整的开发能力。执行这条命令：

$JAVA_HOME/bin/javac -version && $JAVA_HOME/bin/java --list-modules | grep java.base

如果第二条命令没有任何输出，或者报错Error: Could not create the Java Virtual Machine，说明这个 JDK 缺失核心模块，必须更换。推荐方案只有两个：

• Windows/macOS 用户：直接去 Adoptium 下载 Eclipse Temurin JDK（选择JDK with HotSpot，版本建议 17 或 21 LTS），它默认打包完整jmods。
• Linux 用户（尤其 Ubuntu/Debian）：放弃apt install openjdk-17-jdk，改用 SDKMAN!：sdk install java 17.0.1-tem。SDKMAN! 安装的 Temurin 版本，模块完整性经过社区长期验证。

提示：不要迷信“最新版”。Spring Boot 3.x 要求 JDK 17+，但 Spring Boot 2.7.x 仍广泛用于老项目，它对 JDK 17 的部分新特性（如密封类）支持不完善。如果你的项目pom.xml里<java.version>是1.8或11，那么你必须安装对应版本的 JDK，并确保 Cursor 只使用这一个版本——混用 JDK 版本是引发Unsupported class file major version错误的头号元凶。

2.2 Cursor 内部的 JDK 绑定：三层校验机制

Cursor 并非只认一个JAVA_HOME。它有一套三层校验机制，每一层失败都会降级，最终导致 AI “看不懂”你的代码：

我踩过的最深的坑是：在一个多模块 Maven 项目里，主pom.xml指定了<java.version>17</java.version>，但某个子模块的pom.xml里又写了<maven.compiler.source>11</maven.compiler.source>。Cursor 默认按主pom.xml绑定 JDK 17，结果在子模块里写var list = new ArrayList<>()时，AI 认为这是 JDK 17 的var，但编译器却按 JDK 11 解析，报错Cannot use 'var' on implicit classes。解决方法是在子模块根目录单独建一个.cursor/settings.json，覆盖 JDK 绑定。这印证了一个经验：Cursor 的 Java 支持，本质是“每个文件夹一个 JDK 信任域”，而不是整个软件一个全局 JDK。

3. Maven 配置：让 Cursor 理解你的“项目宇宙”

Maven 不只是一个构建工具，它是 Java 项目的“元数据中枢”。它定义了依赖坐标、插件行为、资源过滤规则、甚至测试框架的版本。Cursor 的 AI 要想精准补全RestTemplate的用法，就必须知道你引入的是spring-web:5.3.31还是spring-web:6.1.0；要想正确提示@Transactional的参数，就必须解析spring-tx的 jar 包里Transactional注解的源码定义。这一切的前提，是 Cursor 能完整、准确地加载并解析你的pom.xml。

3.1 为什么mvn clean compile成功，Cursor 却报“Unresolved dependency”？

这是最常被问到的问题。根源在于：Maven 的本地仓库（.m2/repository）和 Cursor 的依赖索引是两套独立系统。你在终端里执行mvn compile，Maven 会下载依赖到~/.m2/repository，并生成target/classes。但 Cursor 的语言服务器（Eclipse JDT LS）需要自己解析pom.xml，然后去~/.m2/repository里找到对应的 jar 包，再反编译或读取其META-INF/MANIFEST.MF和module-info.class，构建出完整的符号表。这个过程比mvn的依赖解析慢得多，且极易受干扰。

最常见的干扰源有三个：

1. 网络代理与镜像源冲突：如果你的settings.xml里配置了阿里云镜像（<mirrorOf>central</mirrorOf>），但 Cursor 启动时没有读取这个文件，它就会尝试从repo.maven.apache.org下载依赖元数据（maven-metadata.xml），而这个域名在国内经常超时。结果就是 Cursor 卡在 “Resolving dependencies…” 状态，AI 补全全部失效。

2. <scope>的隐形陷阱：<scope>test</scope>的依赖（如junit-jupiter）在main目录下是不可见的。但很多开发者会把test依赖写在父pom.xml的<dependencyManagement>里，然后子模块不声明scope，导致 Cursor 误认为junit是compile作用域，从而在main代码里错误地补全Assertions.assertEquals()。

3. BOM（Bill of Materials）的版本锁定失效：Spring Boot 的spring-boot-dependenciesBOM 会统一管理spring-*系列组件的版本。但如果 Cursor 的 JDT LS 没有正确加载 BOM，它就无法知道spring-web和spring-core必须是同一版本，可能导致补全时出现NoSuchMethodError的预判错误。

解决方案不是“重启 Cursor”，而是强制它重新加载 Maven 项目模型。快捷键是Cmd+Shift+P（Mac）或Ctrl+Shift+P（Win/Linux），输入Java: Reload Project并执行。这个命令会触发 JDT LS 重新解析pom.xml，重新下载缺失的元数据，并重建整个依赖图谱。实测发现，90% 的“依赖报红”问题，执行一次Reload Project就能解决。

注意：Reload Project不会清理target/或~/.m2/repository，它只刷新 Cursor 内部的索引。所以不用担心影响你的构建产物。但如果你修改了settings.xml的镜像配置，必须先关闭 Cursor，再重新打开，否则它仍会读取旧的缓存。

3.2 多模块项目：如何让 Cursor “看见”模块间的血缘关系？

一个典型的 SpringBoot 多模块项目结构如下：

my-project/ ├── pom.xml # 父pom，定义<modules> ├── common/ │ └── pom.xml # 子模块，提供工具类 ├── api/ │ └── pom.xml # 子模块，定义DTO和Feign接口 └── service/ └── pom.xml # 子模块，主业务逻辑，依赖common和api

问题来了：当你在service/src/main/java里写new CommonUtils().formatDate(...)，Cursor 为什么有时能跳转到common模块的源码，有时却提示 “Cannot find declaration to go to”？答案是：Cursor 默认只将当前打开的文件夹（workspace）作为“根项目”，其他模块被视为外部依赖。它不会自动递归扫描父目录下的所有pom.xml。

正确的做法是：在 Cursor 中，不要只打开service/文件夹，而是打开最外层的my-project/文件夹。这样，JDT LS 启动时会识别这是一个多模块 Maven 项目，并自动将common/和api/作为“已知模块”纳入索引。此时，service模块对common的依赖，不再是~/.m2/repository/com/example/common/1.0.0/common-1.0.0.jar这样的二进制包，而是../common/target/classes这样的实时编译输出，AI 补全和跳转就能做到毫秒级响应。

如果你因为某些原因（比如my-project/太大，加载慢）必须只打开service/，那就要手动告诉 Cursorcommon模块的位置。在service/.cursor/settings.json中添加：

{ "java.project.referencedLibraries": [ "../common/target/classes", "../api/target/classes" ] }

这个配置会让 Cursor 把指定路径当作“源码库”来索引，效果等同于在 IDEA 里添加 Module Dependency。但要注意：target/classes必须存在，所以你需要先在终端里cd ../common && mvn compile一次。

4. Spring Boot 专项配置：激活 AI 的“框架大脑”

配置好 JDK 和 Maven，Cursor 就能识别 Java 语法和基本依赖了。但这只是“能用”，离“好用”还差一个关键环节：让 Cursor 的 AI 模型理解 Spring Boot 的编程范式。Spring Boot 不是简单的 Java 库集合，它有一套约定大于配置的运行时模型：自动配置（Auto-Configuration）、条件化 Bean 创建（@ConditionalOnClass）、外部化配置（application.yml）、以及 Actuator 端点。AI 如果不懂这套模型，它给你补全的@Bean方法，可能根本不会被 Spring 容器扫描到。

4.1spring-boot-starter-parent：不只是继承，更是“语义锚点”

很多新手会忽略pom.xml里这行：

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>3.2.0</version> <relativePath/> </parent>

他们觉得这只是为了省略一堆<version>标签。但在 Cursor 的世界里，这行代码是一个至关重要的“语义锚点”。当 JDT LS 解析到这个parent，它会立刻加载spring-boot-dependenciesBOM，并据此推断：这个项目是一个 Spring Boot 项目，应该启用 Spring Boot 特有的语言特性支持。

如果这个parent缺失，或者被注释掉（比如为了自定义maven-compiler-plugin版本），Cursor 就会退化为一个普通的 Java 项目。后果是：

• @SpringBootApplication注解旁边不会出现绿色的 “Run” 按钮；
• application.yml文件里写server:，AI 不会自动补全port:、servlet:等子属性；
• @Value("${app.name}")里的app.name，AI 无法关联到application.yml中的定义，也就无法做跨文件的引用检查。

解决方案很简单：确保pom.xml的<parent>块存在且有效。如果你确实需要覆盖某些插件版本，不要删除parent，而是用<pluginManagement>来覆盖：

<build> <pluginManagement> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.11.0</version> </plugin> </plugins> </pluginManagement> </build>

这样既保留了parent的语义，又满足了定制需求。

4.2application.yml：让 AI 理解你的“配置宇宙”

Spring Boot 的灵魂在于外部化配置。Cursor 的 AI 要想成为你的“配置助手”，就必须能读懂application.yml。但默认情况下，它只会把它当作一个普通 YAML 文件高亮。要激活它的“Spring Boot 配置模式”，需要两个动作：

1. 确保文件名和位置正确：必须是src/main/resources/application.yml（或.properties）。放在src/test/resources/或其他路径下，AI 无法关联。

2. 安装并启用 Spring Boot Tools 插件：虽然 Cursor 内置了 Java 支持，但 Spring Boot 的专属特性（如配置属性提示、Profile 切换、Actuator 端点导航）需要额外插件。在 Cursor 的 Extensions 商店（Cmd+Shift+X）中搜索Spring Boot Tools，安装并重启。

安装后，当你在application.yml里输入spring:，AI 会立即弹出一个包含spring.application.name、spring.profiles.active、spring.main.banner-mode等上百个属性的补全列表。更厉害的是，它能根据你已写的属性，智能推断后续。例如，你写了spring.datasource.url: jdbc:mysql://localhost:3306/mydb，接着输入spring.datasource.，AI 就会优先补全username:、password:、driver-class-name:这些 MySQL 相关属性，而不是泛泛的spring.datasource.hikari.*。

这个能力的背后，是 Cursor 加载了 Spring Boot 官方发布的spring-configuration-metadata.json。这个 JSON 文件定义了每个配置项的类型、描述、是否必需、以及与其他配置项的关联关系。所以，如果你用的是自定义 Starter，或者公司内部的私有 Starter，AI 就无法补全它的配置项。这时，你需要在你的 Starter 项目里，按照 Spring Boot 官方文档 的要求，在src/main/resources/META-INF/下添加additional-spring-configuration-metadata.json，然后重新mvn install。Cursor 下次加载你的 Starter 依赖时，就能识别了。

5. Lombok 与注解处理器：消除 “AI 知道，但编译器不知道” 的鸿沟

Lombok 是 Java 开发者的“语法糖神器”，但也是 Cursor 配置里最易被忽视的“断点”。当你写@Data，AI 能完美补全getUser()、setUser()方法，但光标移到user.getName()上时，却提示 “Cannot resolve method ‘getName’ in ‘User’”。这就是典型的“AI 知道，但编译器不知道”——AI 基于 Lombok 注解的语义推断出了方法，但 Cursor 的编译器（JDT）没有启用 Lombok 的注解处理器，所以它看到的User类，真的只有private String name;这一行字段。

5.1 为什么 Lombok 的@Data在 Cursor 里“半失效”？

根本原因在于：Lombok 的工作原理是“编译期代码生成”，它需要一个 Annotation Processor（注解处理器）在javac编译时，扫描@Data等注解，并动态插入getter/setter/toString的字节码。Cursor 的 JDT LS 内置了一个精简版的javac，但它默认不加载任何第三方注解处理器。所以，JDT 看到的User.java，就是一个只有字段的“残缺”类。

解决方案是双重的：既要让 JDT 知道 Lombok 的存在，又要让它知道去哪里找 Lombok 的处理器。

1. 在pom.xml中正确声明 Lombok 依赖：

   <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency>

   关键是<optional>true</optional>。这告诉 Maven，Lombok 只在编译期需要，不打入最终的jar包。同时，它也向 JDT LS 发出一个信号：这是一个编译期工具，需要特殊对待。

2. 在.cursor/settings.json中显式启用注解处理：

   { "java.configuration.updateBuildConfiguration": "interactive", "java.configuration.annotations": [ "lombok.*", "org.springframework.*" ], "java.configuration.annotationProcessors": [ "lombok.launch.AnnotationProcessorHider$AnnotationProcessor" ] }

   这段配置做了三件事：

   • "java.configuration.updateBuildConfiguration": "interactive"：开启交互式构建配置，允许 JDT 动态响应pom.xml的变更。
   • "java.configuration.annotations"：告诉 JDT，哪些包下的注解需要被特殊处理。
   • "java.configuration.annotationProcessors"：直接指定 Lombok 注解处理器的全限定名。这个类名是 Lombok 1.18.30+ 版本的标准入口，必须精确匹配。

5.2@Builder与@AllArgsConstructor的协同陷阱

Lombok 的组合注解常常带来意想不到的冲突。比如，你在一个User类上同时用了@Data和@Builder：

@Data @Builder public class User { private Long id; private String name; }

AI 会完美补全User.builder().id(1L).name("John").build()。但当你在另一个类里写new User()时，AI 却提示 “Constructor User() is undefined”。这是因为@Builder会生成一个私有的全参构造器，并抑制了 Lombok 自动生成的无参构造器（@Data默认会生成）。JDT 在索引时，只看到了私有构造器，所以认为new User()是非法的。

这个问题的根源，是 Cursor 的 AI 和 JDT 的编译器对 Lombok 注解的“解读粒度”不同。AI 基于 Lombok 的文档做语义推断，而 JDT 是基于实际生成的字节码做符号解析。要解决它，必须让两者达成一致。办法有两个：

• 方案一（推荐）：显式添加@NoArgsConstructor

  @Data @Builder @NoArgsConstructor // 显式要求无参构造器 @AllArgsConstructor // 显式要求全参构造器（@Builder 需要） public class User { ... }

  这样，JDT 索引到的就是一个明确的public User()构造器。

• 方案二：在pom.xml中配置 Lombok 的lombok.config
  在项目根目录创建lombok.config文件，写入：
  

  lombok.anyConstructor.addConstructorProperties = true lombok.noArgsConstructor.extraPrivate = false

  这会全局改变 Lombok 的生成策略，让@Data生成的无参构造器是public的。

无论选哪个方案，配置完后都必须执行一次Java: Reload Project，让 JDT 重新生成符号表。这是打通 Lombok “语义”与“字节码”之间鸿沟的最后一步。

6. 实战排错：从 “AI 不工作” 到 “AI 懂我” 的完整排查链路

配置完成不等于万事大吉。在真实项目中，你会遇到各种“看似配置正确，但 AI 就是不给力”的情况。下面是一套我总结的、可复现的、从表象到根因的完整排查链路。它不是罗列错误代码，而是模拟一个资深工程师坐在你旁边，一步步带你定位问题的过程。

6.1 现象：@Autowired标红，但mvn compile成功

第一步：确认问题范围
在service/模块里，写一个@Service类，注入UserRepository：

@Service public class UserService { @Autowired private UserRepository userRepository; // 这里标红 }

先别急着查配置。打开终端，进入service/目录，执行：

mvn compile -X | grep "UserRepository"

如果输出里有Compiling 1 source file to .../target/classes，并且没有关于UserRepository的错误，说明编译器没问题。问题一定出在 Cursor 的索引层面。

第二步：检查依赖是否被正确解析
按下Cmd+Shift+P，输入Java: Open Java Language Server Log。在打开的日志文件里，搜索UserRepository。如果看到类似Could not resolve type 'UserRepository'或Failed to load class file for 'UserRepository'的日志，说明 JDT 没有找到这个类的定义。

这时，去common/模块（假设UserRepository在那里）的pom.xml里，检查它的<packaging>是jar还是pom。如果是pom，那它根本不会生成target/classes，service模块依赖的只是一个空壳。必须改成<packaging>jar</packaging>，然后cd ../common && mvn compile。

第三步：验证 Spring 上下文扫描
即使UserRepository类存在，如果它不在 Spring 的 Component Scan 路径下，@Autowired依然会失败。在service/src/main/java下，检查Application.java的@SpringBootApplication注解是否在包的最外层。比如，Application.java在com.example.service包下，那么UserRepository就必须在com.example.common或com.example.service的子包里。如果它在org.mycompany.repo这种完全无关的包下，就需要在Application.java上加@ComponentScan("org.mycompany.repo")。

Cursor 的 AI 会读取@ComponentScan的值，并据此缩小@Autowired的候选范围。所以，如果你加了@ComponentScan，一定要确保它的值是正确的字符串，而不是一个拼写错误的包名。

6.2 现象：application.yml里写spring.profiles.active: dev，但@Profile("dev")的 Bean 不生效

这通常不是配置问题，而是 Cursor 的“运行时上下文”缺失。Cursor 本身不运行 Spring Boot 应用，它只是静态分析。所以，@Profile的条件判断，它无法在编辑时动态执行。

但你可以给它一个“提示”。在application.yml的spring.profiles.active行末尾，加上一个特殊的注释：

spring: profiles: active: dev # cursor-profile: dev

这个# cursor-profile: dev注释，是 Cursor 识别当前活跃 Profile 的约定。当你这样写后，AI 在分析@Profile("dev")的 Bean 时，就会知道这个 Bean 是“当前生效”的，从而在补全和跳转时给予更高权重。

同理，对于@ConditionalOnProperty(name="app.feature.enabled", havingValue="true")，你可以在application.yml里写：

app: feature: enabled: true # cursor-property: app.feature.enabled=true

这样，AI 就能理解这个条件是满足的，不会把相关的 Bean 当作“死代码”忽略。

这套注释机制，是我和团队在多个大型项目中摸索出来的“Cursor 可感知的配置契约”。它不改变任何运行时行为，只是为 AI 提供了一个可靠的、静态的上下文信号。比起在设置里填一堆 Profile 名字，这种方式更精准、更可控，也更容易被团队成员理解和遵守。

7. 最后一点心得：把 Cursor 当作“会提问的实习生”，而不是“不犯错的机器人”

写到这里，我想分享一个贯穿我所有 Cursor 配置实践的核心理念：永远不要期待 Cursor 做出 100% 正确的决定，而是要训练它学会在不确定时，向你提出一个精准的问题。这才是它作为 AI 编程助手的最高价值。

举个例子。我在配置一个 Kafka 消费者时，写了@KafkaListener(topics = "user-event")，AI 立刻补全了containerFactory = "kafkaListenerContainerFactory"。这个补全本身没错，但我们的项目里其实有两个工厂：一个用于顺序消费，一个用于并发消费。AI 无法知道我此刻想要哪一个。

这时，我没有去翻文档找配置名，而是直接在containerFactory =后面敲了一个空格，然后输入?。神奇的事情发生了：Cursor 的补全列表瞬间变成了：

• kafkaListenerContainerFactory (sequential)
• kafkaListenerContainerFactory (concurrent)
• ... and 3 more

它把我项目里所有以kafkaListenerContainerFactory开头的 Bean 名称都列了出来，并附上了括号里的语义标签。这个?触发了 Cursor 的“模糊查询+语义增强”模式，它不再猜测，而是把选择权交还给我，并提供了足够的上下文信息让我做决策。

类似的技巧还有很多：

• 在@Value里写${，然后按Ctrl+Space，它会列出application.yml里所有已定义的属性名；
• 在pom.xml的<dependency>块里，写<artifactId>，然后按Cmd+Enter，它会弹出一个对话框，让你搜索 Maven Central 上的最新版本；
• 在写 SQL 查询时，把光标放在SELECT关键字上，按Cmd+Shift+I，它会分析你当前 DAO 层的实体类，生成一个符合@Table和@Column映射的完整 SELECT 语句。

所有这些，都不是 Cursor “天生就会”，而是你通过一次次的Reload Project、一次次的.cursor/settings.json调整、一次次的# cursor-xxx注释，把它从一个“语法高亮器”，逐步训练成了一个“懂你项目、懂你习惯、懂你意图”的伙伴。

所以，当你下次再看到 “cursor 配置 java 项目环境” 这个搜索词时，请记住：配置的终点，不是让所有红波浪线消失，而是让第一个?出现在你最需要它的地方。那才是 Cursor 真正开始工作的时刻。