Spring AOT优化转换的使用原理详解

// AOT 处理生成的代表性代码结构
public class ApplicationAotProcessor {
    // 生成的 Bean 定义方法
    @Generated
    public BeanDefinition myServiceBeanDefinition() {
        return BeanDefinitionBuilder
            .genericBeanDefinition(MyService.class)
            .setScope(BeanDefinition.SCOPE_SINGLETON)
            .getBeanDefinition();
    }
    // 生成的初始化代码
    @Generated  
    public static void applyAotProcessing(GenericApplicationContext context) {
        context.registerBean("myService", MyService.class);
    }
}

# 安装 GraalVM
sdk install java 22.3.r17-grl
sdk use java 22.3.r17-grl
# 安装 Native Image 工具
gu install native-image

package com.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class AotDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(AotDemoApplication.class, args);
    }
}

package com.example.controller;
import com.example.service.GreetingService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
@RestController
public class GreetingController {
    private final GreetingService greetingService;
    public GreetingController(GreetingService greetingService) {
        this.greetingService = greetingService;
    }
    @GetMapping("/greet/{name}")
    public Map<String, String> greet(@PathVariable String name) {
        String message = greetingService.generateGreeting(name);
        return Map.of("message", message, "timestamp", java.time.Instant.now().toString());
    }
    @GetMapping("/")
    public Map<String, String> home() {
        return Map.of("status", "OK", "service", "Spring AOT Demo");
    }
}

package com.example.service;
import org.springframework.stereotype.Service;
import java.util.concurrent.atomic.AtomicLong;
@Service
public class GreetingService {
    private final AtomicLong counter = new AtomicLong();
    public String generateGreeting(String name) {
        long count = counter.incrementAndGet();
        return String.format("Hello, %s! This is greeting #%d", name, count);
    }
}

package com.example.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.format.DateTimeFormatter;
@Configuration
public class AppConfig {
    @Bean
    public DateTimeFormatter dateTimeFormatter() {
        // 这个 Bean 将在 AOT 阶段被优化
        return DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project>
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>spring-aot-demo</artifactId>
    <version>1.0.0</version>
    <properties>
        <java.version>17</java.version>
        <graalvm.version>22.3.0</graalvm.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                        <builder>paketobuildpacks/builder-jammy-base:latest</builder>
                        <env>
                            <BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE>
                        </env>
                    </image>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.graalvm.buildtools</groupId>
                <artifactId>native-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

// ❌ 避免这样写（AOT 无法分析）
Class<?> clazz = Class.forName(className);
Object instance = clazz.getDeclaredConstructor().newInstance();
// ✅ 推荐写法（AOT 友好）
@Configuration
public class FactoryConfig {
    @Bean
    @ConditionalOnProperty(name = "service.type", havingValue = "default")
    public MyService defaultService() {
        return new DefaultService();
    }
}

// ✅ 明确声明需要包含的资源
@Configuration
public class ResourceConfig {
    @Bean
    public ResourcePatternResolver resourceResolver() {
        return new PathMatchingResourcePatternResolver();
    }
    // 使用 AOT 友好的资源加载方式
    public List<String> loadConfigurations() throws IOException {
        return Stream.of(resourceResolver().getResources("classpath:config/*.json"))
                   .map(this::readResource)
                   .collect(Collectors.toList());
    }
}

// ✅ 使用接口明确的代理
public interface UserService {
    String getUserName(Long id);
}
@Service 
public class UserServiceImpl implements UserService {
    // AOT 可以正确生成代理
}
// ❌ 避免基于类的动态代理（CGLIB）
// @Configuration 注解的类默认使用 CGLIB，AOT 可以处理，但要谨慎使用复杂特性

import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.TypeHint;
public class CustomRuntimeHints implements RuntimeHintsRegistrar {
    @Override
    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
        // 注册需要反射的类
        hints.reflection().registerType(MyDynamicClass.class, 
            TypeHint.builtWith(MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS));
        // 注册资源文件
        hints.resources().registerPattern("templates/*.html");
    }
}

public class SerializationHints implements RuntimeHintsRegistrar {
    @Override
    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
        hints.serialization().registerType(MySerializableClass.class);
    }
}