使用静态编译构建Java微服务

public class Demo {
    public int add(int a, int b) {
        return a + b;
    }
}

public int calculate(int x) {
    return add(x, 10) + multiply(x, 2);
}

private int add(int a, int b) {
    return a + b;
}

private int multiply(int a, int b) {
    return a * b;
}

public int calculate(int x) {
    // 内联add方法
    int temp1 = x + 10;
    // 内联multiply方法
    int temp2 = x * 2;
    return temp1 + temp2;
}

public void test() {
    Point p = new Point(1, 2);
    int sum = p.x + p.y;
}

class Point {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }
}

public void test() {
    int x = 1;
    int y = 2;
    int sum = x + y;
}

public String concat(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
}

// 原始代码
for (int i = 0; i < 100; i++) {
    sum += array[i];
}

// 展开后（伪代码）
for (int i = 0; i < 100; i += 4) {
    sum += array[i];
    sum += array[i + 1];
    sum += array[i + 2];
    sum += array[i + 3];
}

// 原始代码
for (int i = 0; i < 100; i++) {
    result[i] = array[i] * factor.getValue();
}

// 优化后
int value = factor.getValue();  // 提到循环外
for (int i = 0; i < 100; i++) {
    result[i] = array[i] * value;
}

public class JITWarmup {
    public static void main(String[] args) {
        for (int i = 0; i < 20000; i++) {
            compute(i);
            if (i % 5000 == 0) {
                long start = System.nanoTime();
                compute(1000);
                System.out.printf("Iteration %d: %d ns%n",
                    i, System.nanoTime() - start);
            }
        }
    }

    static int compute(int n) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += i * i;
        }
        return sum;
    }
}

interface Service {
    void execute();
}

class FastService implements Service {
    public void execute() { /* 快速实现 */ }
}

// 运行一段时间后，JIT假设service永远是FastService，内联execute方法
Service service = new FastService();
for (int i = 0; i < 100000; i++) {
    service.execute();  // 内联为FastService.execute
}

// 突然换实现，触发反优化
service = new SlowService();
service.execute();  // 之前的优化失效，回退到解释执行

public record Product(
    String id,
    String name,
    BigDecimal price,
    int stock
) {}

public record OrderRequest(
    String productId,
    int quantity,
    String userId
) {}

public record OrderResponse(
    String orderId,
    String status,
    BigDecimal totalAmount
) {}

@Service
public class OrderService {
    private final StringRedisTemplate redis;
    private final RestTemplate restTemplate;

    public OrderService(StringRedisTemplate redis, RestTemplate restTemplate) {
        this.redis = redis;
        this.restTemplate = restTemplate;
    }

    public OrderResponse createOrder(OrderRequest request) {
        // 1. 检查库存（模拟Redis查询）
        String stockKey = "product:" + request.productId() + ":stock";
        String stockStr = redis.opsForValue().get(stockKey);

        if (stockStr == null) {
            throw new BusinessException("Product not found");
        }

        int stock = Integer.parseInt(stockStr);
        if (stock < request.quantity()) {
            throw new BusinessException("Insufficient stock");
        }

        // 2. 扣减库存
        redis.opsForValue().decrement(stockKey, request.quantity());

        // 3. 调用支付服务（模拟HTTP调用）
        PaymentRequest payment = new PaymentRequest(
            request.userId(),
            calculateAmount(request)
        );

        PaymentResponse paymentResp = restTemplate.postForObject(
            "http://payment-service/api/pay",
            payment,
            PaymentResponse.class
        );

        // 4. 生成订单
        String orderId = UUID.randomUUID().toString();

        return new OrderResponse(
            orderId,
            "COMPLETED",
            calculateAmount(request)
        );
    }

    private BigDecimal calculateAmount(OrderRequest request) {
        // 简化：实际应查询商品价格
        return BigDecimal.valueOf(99.99).multiply(BigDecimal.valueOf(request.quantity()));
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderService orderService;

    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody OrderRequest request) {
        OrderResponse response = orderService.createOrder(request);
        return ResponseEntity.ok(response);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Order> getOrder(@PathVariable String id) {
        // 实现查询逻辑
        return ResponseEntity.ok(/* ... */);
    }
}

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException ex) {
        return ResponseEntity
            .status(HttpStatus.BAD_REQUEST)
            .body(new ErrorResponse(ex.getMessage()));
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception ex) {
        return ResponseEntity
            .status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(new ErrorResponse("Internal server error"));
    }
}

record ErrorResponse(String message) {}

@Configuration
public class MyRuntimeHints implements RuntimeHintsRegistrar {
    @Override
    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
        // 手动注册反射Hint
        hints.reflection().registerType(
            OrderRequest.class,
            MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
            MemberCategory.DECLARED_FIELDS
        );

        // 注册资源
        hints.resources().registerPattern("templates/*.html");

        // 注册序列化
        hints.serialization().registerType(Product.class);
    }
}