refactor(page): 删除旧版页面文件

.agents/skills/kotlin-tooling-java-to-kotlin/references/frameworks/MICRONAUT.md

@@ -0,0 +1,120 @@
+# Micronaut Conversion Guide
+
+## When This Applies
+
+This guide applies when the Java source contains imports matching `io.micronaut.*`.
+This covers Micronaut HTTP, Micronaut Data, and Micronaut Security.
+
+## Key Rules
+
+### 1. Constructor injection is the default
+
+Micronaut uses compile-time dependency injection via constructor injection by default.
+This maps naturally to Kotlin's primary constructor. Remove `@Inject` when there is
+only one constructor — Micronaut discovers it automatically.
+
+### 2. Stereotype annotations
+
+`@Singleton`, `@Controller`, `@Client`, `@Repository` — preserve these exactly.
+No annotation site target is needed.
+
+### 3. @Value annotation
+
+Escape `$` in Kotlin to prevent string template interpretation:
+
+```kotlin
+@Value("\${config.key}") val configKey: String
+```
+
+### 4. @Inject field injection → constructor injection
+
+Replace `@Inject` on fields with constructor parameters in Kotlin's primary constructor.
+This eliminates `lateinit var` and makes dependencies immutable.
+
+### 5. AOP interceptors require open classes
+
+Classes using AOP annotations (`@Around`, `@Introduction`, `@Cacheable`) must be `open`
+in Kotlin because Micronaut generates subclass proxies for them at compile time.
+
+### 6. Bean factories
+
+`@Factory` classes and their `@Bean`-annotated methods should be `open` so Micronaut
+can manage their lifecycle through subclassing.
+
+### 7. @ConfigurationProperties
+
+Convert to a class with mutable properties. Use `lateinit var` for required `String`
+properties and `var` with defaults for primitives. The class must be `open`.
+
+---
+
+## Examples
+
+### Example 1: Micronaut Controller with Constructor Injection
+
+**Java:**
+
+```java
+package com.acme.web;
+
+import io.micronaut.http.annotation.Controller;
+import io.micronaut.http.annotation.Get;
+import io.micronaut.http.annotation.PathVariable;
+import jakarta.inject.Inject;
+
+@Controller("/api/orders")
+public class OrderController {
+
+    private final OrderService orderService;
+    private final InventoryClient inventoryClient;
+
+    @Inject
+    public OrderController(OrderService orderService, InventoryClient inventoryClient) {
+        this.orderService = orderService;
+        this.inventoryClient = inventoryClient;
+    }
+
+    @Get("/{id}")
+    public OrderDto getOrder(@PathVariable Long id) {
+        return orderService.findById(id);
+    }
+
+    @Get
+    public List<OrderDto> listOrders() {
+        return orderService.findAll();
+    }
+}
+```
+
+**Kotlin:**
+
+```kotlin
+package com.acme.web
+
+import io.micronaut.http.annotation.Controller
+import io.micronaut.http.annotation.Get
+import io.micronaut.http.annotation.PathVariable
+
+@Controller("/api/orders")
+class OrderController(
+    private val orderService: OrderService,
+    private val inventoryClient: InventoryClient
+) {
+
+    @Get("/{id}")
+    fun getOrder(@PathVariable id: Long): OrderDto? {
+        return orderService.findById(id)
+    }
+
+    @Get
+    fun listOrders(): List<OrderDto> {
+        return orderService.findAll()
+    }
+}
+```
+
+Key changes:
+- `@Inject` is removed — Micronaut auto-discovers the single constructor.
+- The `jakarta.inject.Inject` import is removed because it is no longer referenced.
+- Constructor parameters become `private val` in the primary constructor.
+- Return type `OrderDto` becomes `OrderDto?` where the service may return null.