□ Java 版本
  □ 目前 Java 版本確認
  □ Java 21 JDK 已安裝
  □ CI/CD 環境已更新 Java 版本
  □ 容器基礎映像已更新

□ 相依套件評估
  □ 列出所有 Maven/Gradle 相依
  □ 確認各套件 Java 21 相容性
  □ 確認各套件 Jakarta EE 11 相容性
  □ 確認 Native Image 相容性（如適用）

□ 程式碼評估
  □ 使用 Spring Boot Migrator 掃描
  □ 盤點已棄用 API 使用情況
  □ 評估反射（Reflection）使用範圍
  □ 評估動態代理（Dynamic Proxy）使用情況

□ 測試覆蓋率
  □ 確認單元測試覆蓋率 > 70%
  □ 確認整合測試完整性
  □ 確認效能測試基準已建立

□ 環境準備
  □ 測試環境已準備
  □ Rollback 計畫已制定
  □ 監控告警已設定

// 1. Virtual Threads (JEP 444) - 大幅提升並發效能
// 舊版寫法 - Platform Threads
ExecutorService executor = Executors.newFixedThreadPool(200);

// 新版寫法 - Virtual Threads
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

// 2. Record Patterns (JEP 440) - 更簡潔的資料解構
// 舊版寫法
if (obj instanceof Point p) {
    int x = p.x();
    int y = p.y();
    // 使用 x, y
}

// 新版寫法
if (obj instanceof Point(int x, int y)) {
    // 直接使用 x, y
}

// 3. Pattern Matching for switch (JEP 441)
// 舊版寫法
String result;
if (obj instanceof Integer i) {
    result = "整數: " + i;
} else if (obj instanceof String s) {
    result = "字串: " + s;
} else {
    result = "未知類型";
}

// 新版寫法
String result = switch (obj) {
    case Integer i -> "整數: " + i;
    case String s  -> "字串: " + s;
    default        -> "未知類型";
};

// 4. Sequenced Collections (JEP 431)
// 新增有序集合介面
SequencedCollection<String> list = new ArrayList<>();
list.addFirst("first");
list.addLast("last");
String first = list.getFirst();
String last = list.getLast();

<!-- Maven 需求 -->
<properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <java.version>21</java.version>
</properties>

<!-- 確保使用新版 Maven Compiler Plugin -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.12.1</version>
    <configuration>
        <release>21</release>
        <compilerArgs>
            <arg>--enable-preview</arg> <!-- 如需使用預覽功能 -->
        </compilerArgs>
    </configuration>
</plugin>

// Gradle 設定
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

tasks.withType(JavaCompile).configureEach {
    options.release = 21
}

# 確認目前 Java 版本
java -version

# 安裝 Java 21（以 SDKMAN 為例）
sdk install java 21.0.2-tem
sdk use java 21.0.2-tem

# Maven 專案
mvn clean compile -Dmaven.compiler.source=21 -Dmaven.compiler.target=21

# Gradle 專案
./gradlew compileJava

# 若遇到反射存取問題
# 在 JAVA_OPTS 中加入
--add-opens java.base/java.lang=ALL-UNNAMED
--add-opens java.base/java.util=ALL-UNNAMED

// 【Breaking Change】@Autowired 建構子注入行為
// 舊版：單一建構子自動注入
// 新版：更嚴格的驗證，建議明確標註

// 舊版可省略 @Autowired
@Service
public class OrderService {
    private final OrderRepository repository;
    
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
}

// 新版建議明確標註（特別是多建構子時）
@Service
public class OrderService {
    private final OrderRepository repository;
    
    @Autowired  // 建議明確標註
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
}

# Spring Boot 3.x - 預設為 eager initialization
spring:
  main:
    lazy-initialization: false

# Spring Boot 4.x - 可透過新設定調整
spring:
  main:
    lazy-initialization: false  # 預設值不變
    # 新增：指定 Bean 延遲載入模式
    lazy-initialization-filter: 
      include-patterns: 
        - "com.example.heavy.*"
      exclude-patterns:
        - "com.example.core.*"

// 【Breaking Change】循環依賴偵測更嚴格

// 問題程式碼 - 會導致啟動失敗
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

@Service  
public class ServiceB {
    @Autowired
    private ServiceA serviceA;
}

// 解決方案 1：使用 @Lazy
@Service
public class ServiceA {
    @Autowired
    @Lazy
    private ServiceB serviceB;
}

// 解決方案 2：重構設計（推薦）
@Service
public class ServiceA {
    private final CommonService commonService;
    
    @Autowired
    public ServiceA(CommonService commonService) {
        this.commonService = commonService;
    }
}

// 解決方案 3：使用 ObjectProvider
@Service
public class ServiceA {
    private final ObjectProvider<ServiceB> serviceBProvider;
    
    @Autowired
    public ServiceA(ObjectProvider<ServiceB> serviceBProvider) {
        this.serviceBProvider = serviceBProvider;
    }
    
    public void doSomething() {
        ServiceB serviceB = serviceBProvider.getIfAvailable();
        // 使用 serviceB
    }
}

// 【Breaking Change】設定檔綁定更嚴格

// 設定類別
@ConfigurationProperties(prefix = "app.datasource")
@Validated
public class DataSourceProperties {
    
    @NotBlank
    private String url;
    
    @NotBlank
    private String username;
    
    // Spring Boot 4.x 要求：
    // 1. 必須有 public getter/setter
    // 2. 或使用 Record
    
    // Getter and Setter
    public String getUrl() { return url; }
    public void setUrl(String url) { this.url = url; }
    
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
}

// Spring Boot 4.x 推薦：使用 Record
@ConfigurationProperties(prefix = "app.datasource")
public record DataSourceProperties(
    @NotBlank String url,
    @NotBlank String username,
    @DefaultValue("5") int connectionTimeout
) {}

// ✅ 推薦
@Service
public class OrderService {
    private final OrderRepository repository;
    private final PaymentService paymentService;
    
    public OrderService(OrderRepository repository, 
                        PaymentService paymentService) {
        this.repository = repository;
        this.paymentService = paymentService;
    }
}

// ❌ 避免
@Service
public class OrderService {
    @Autowired
    private OrderRepository repository;
    
    @Autowired
    private PaymentService paymentService;
}

// ❌ 避免大量使用 @Value
@Service
public class NotificationService {
    @Value("${notification.email.host}")
    private String emailHost;
    
    @Value("${notification.email.port}")
    private int emailPort;
}

// ✅ 推薦使用 @ConfigurationProperties
@Service
public class NotificationService {
    private final NotificationProperties properties;
    
    public NotificationService(NotificationProperties properties) {
        this.properties = properties;
    }
}

// Spring Boot 4.x - 預設可啟用 Virtual Threads 處理 HTTP 請求

// application.yml 設定
// spring:
//   threads:
//     virtual:
//       enabled: true

// 效果：每個 HTTP 請求由 Virtual Thread 處理
// 適合 I/O 密集型應用（資料庫查詢、外部 API 呼叫）

// 【Breaking Change】ResponseEntity 泛型要求更嚴格

// 舊版可省略泛型
@GetMapping("/users/{id}")
public ResponseEntity getUser(@PathVariable Long id) {
    return ResponseEntity.ok(userService.findById(id));
}

// 新版要求明確泛型
@GetMapping("/users/{id}")
public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
    return ResponseEntity.ok(userService.findById(id));
}

// Spring Boot 4.x 新增功能：更靈活的參數綁定

// 1. Record 作為請求參數
public record SearchCriteria(
    String keyword,
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate,
    @RequestParam(defaultValue = "0") int page,
    @RequestParam(defaultValue = "20") int size
) {}

@GetMapping("/search")
public Page<Product> search(SearchCriteria criteria) {
    return productService.search(criteria);
}

// 2. 更嚴格的驗證
@PostMapping("/users")
public ResponseEntity<UserDto> createUser(
    @Valid @RequestBody CreateUserRequest request) {
    // 驗證失敗會自動回傳 400 Bad Request
    return ResponseEntity.ok(userService.create(request));
}

// Spring Boot 4.x 改進的驗證錯誤格式

// 新版預設錯誤回應格式
{
    "type": "https://example.com/problems/validation-error",
    "title": "Validation Error",
    "status": 400,
    "detail": "Request validation failed",
    "instance": "/api/users",
    "errors": [
        {
            "field": "email",
            "message": "must be a valid email address",
            "rejectedValue": "invalid-email"
        }
    ]
}

// 自定義驗證錯誤處理
@RestControllerAdvice
public class ValidationExceptionHandler {
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ProblemDetail handleValidationException(
            MethodArgumentNotValidException ex) {
        
        ProblemDetail problem = ProblemDetail
            .forStatusAndDetail(HttpStatus.BAD_REQUEST, "Validation failed");
        
        List<FieldError> fieldErrors = ex.getBindingResult()
            .getFieldErrors()
            .stream()
            .map(error -> new FieldError(
                error.getField(),
                error.getDefaultMessage(),
                error.getRejectedValue()
            ))
            .toList();
        
        problem.setProperty("errors", fieldErrors);
        return problem;
    }
    
    record FieldError(String field, String message, Object rejectedValue) {}
}

// Spring Boot 4.x 全面採用 RFC 7807 Problem Details

// 啟用 Problem Details（Spring Boot 4.x 預設啟用）
// application.yml
// spring:
//   mvc:
//     problemdetails:
//       enabled: true

// 自定義業務例外
public class BusinessException extends RuntimeException {
    private final String errorCode;
    private final HttpStatus status;
    
    public BusinessException(String errorCode, String message, HttpStatus status) {
        super(message);
        this.errorCode = errorCode;
        this.status = status;
    }
    
    // Getters...
}

// 統一例外處理
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(BusinessException.class)
    public ProblemDetail handleBusinessException(BusinessException ex) {
        ProblemDetail problem = ProblemDetail
            .forStatusAndDetail(ex.getStatus(), ex.getMessage());
        
        problem.setTitle("Business Error");
        problem.setType(URI.create("https://api.example.com/errors/" + ex.getErrorCode()));
        problem.setProperty("errorCode", ex.getErrorCode());
        problem.setProperty("timestamp", Instant.now());
        
        return problem;
    }
    
    @ExceptionHandler(Exception.class)
    public ProblemDetail handleGenericException(Exception ex) {
        ProblemDetail problem = ProblemDetail
            .forStatusAndDetail(HttpStatus.INTERNAL_SERVER_ERROR, 
                "An unexpected error occurred");
        
        problem.setTitle("Internal Server Error");
        // 生產環境不應暴露詳細錯誤訊息
        
        return problem;
    }
}

// Spring Boot 4.x WebFlux 改進

// 1. 更好的錯誤處理
@RestController
@RequestMapping("/api/reactive")
public class ReactiveController {
    
    @GetMapping("/users/{id}")
    public Mono<UserDto> getUser(@PathVariable Long id) {
        return userService.findById(id)
            .switchIfEmpty(Mono.error(new ResourceNotFoundException("User not found")));
    }
}

// 2. 改進的 ServerResponse Builder
@Bean
public RouterFunction<ServerResponse> userRoutes(UserHandler handler) {
    return RouterFunctions.route()
        .GET("/users/{id}", handler::getUser)
        .POST("/users", handler::createUser)
        .onError(ResourceNotFoundException.class, (ex, request) ->
            ServerResponse.status(HttpStatus.NOT_FOUND)
                .contentType(MediaType.APPLICATION_PROBLEM_JSON)
                .bodyValue(ProblemDetail.forStatusAndDetail(
                    HttpStatus.NOT_FOUND, ex.getMessage()))
        )
        .build();
}

// Spring Boot 4.x REST API 設計範例

@RestController
@RequestMapping("/api/v1/orders")
@Tag(name = "Order API", description = "訂單管理相關 API")
public class OrderController {
    
    private final OrderService orderService;
    
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
    
    @GetMapping
    @Operation(summary = "查詢訂單列表")
    public Page<OrderDto> listOrders(
            @ParameterObject OrderSearchCriteria criteria,
            @ParameterObject Pageable pageable) {
        return orderService.search(criteria, pageable);
    }
    
    @GetMapping("/{id}")
    @Operation(summary = "查詢單一訂單")
    public OrderDto getOrder(@PathVariable Long id) {
        return orderService.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("Order", id));
    }
    
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    @Operation(summary = "建立訂單")
    public OrderDto createOrder(@Valid @RequestBody CreateOrderRequest request) {
        return orderService.create(request);
    }
    
    @PutMapping("/{id}")
    @Operation(summary = "更新訂單")
    public OrderDto updateOrder(
            @PathVariable Long id,
            @Valid @RequestBody UpdateOrderRequest request) {
        return orderService.update(id, request);
    }
    
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    @Operation(summary = "刪除訂單")
    public void deleteOrder(@PathVariable Long id) {
        orderService.delete(id);
    }
}

// Spring Security 7.x 預設啟用的安全頭部
// X-Content-Type-Options: nosniff
// X-Frame-Options: DENY
// X-XSS-Protection: 0 (已棄用，改用 CSP)
// Strict-Transport-Security: max-age=31536000
// Content-Security-Policy: default-src 'self'

// 自定義安全頭部
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .headers(headers -> headers
            .frameOptions(frame -> frame.sameOrigin())
            .contentSecurityPolicy(csp -> csp
                .policyDirectives("default-src 'self'; script-src 'self' 'unsafe-inline'")
            )
        )
        .build();
}

// ❌ 舊版寫法 - Spring Security 7.x 已移除
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
            .antMatchers("/public/**").permitAll()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
        .and()
        .formLogin()
            .loginPage("/login")
            .permitAll()
        .and()
        .logout()
            .permitAll();
    return http.build();
}

// ✅ 新版寫法 - Lambda DSL（必須使用）
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/public/**").permitAll()
            .requestMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
        )
        .formLogin(form -> form
            .loginPage("/login")
            .permitAll()
        )
        .logout(logout -> logout
            .permitAll()
        )
        .build();
}

// Spring Security 7.x Method Security 設定

@Configuration
@EnableMethodSecurity  // 取代 @EnableGlobalMethodSecurity
public class MethodSecurityConfig {
    // 預設啟用 @PreAuthorize, @PostAuthorize
    // 若需 @Secured，需明確設定
}

// 使用範例
@Service
public class OrderService {
    
    @PreAuthorize("hasRole('USER')")
    public List<Order> findMyOrders() {
        // ...
    }
    
    @PreAuthorize("hasRole('ADMIN') or @orderSecurity.isOwner(#orderId)")
    public Order findById(Long orderId) {
        // ...
    }
    
    @PostAuthorize("returnObject.userId == authentication.principal.id")
    public Order findOrderForCurrentUser(Long orderId) {
        // ...
    }
}

// 自定義安全表達式
@Component("orderSecurity")
public class OrderSecurityExpressions {
    
    private final OrderRepository orderRepository;
    
    public OrderSecurityExpressions(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
    
    public boolean isOwner(Long orderId) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        return orderRepository.findById(orderId)
            .map(order -> order.getUserId().equals(getCurrentUserId(auth)))
            .orElse(false);
    }
    
    private Long getCurrentUserId(Authentication auth) {
        // 取得當前使用者 ID
        return ((CustomUserDetails) auth.getPrincipal()).getId();
    }
}

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {
    
    private final UserDetailsService userDetailsService;
    private final JwtAuthenticationFilter jwtAuthFilter;
    
    public SecurityConfig(UserDetailsService userDetailsService,
                          JwtAuthenticationFilter jwtAuthFilter) {
        this.userDetailsService = userDetailsService;
        this.jwtAuthFilter = jwtAuthFilter;
    }
    
    @Bean
    public SecurityFilterChain apiSecurityFilterChain(HttpSecurity http) throws Exception {
        return http
            .securityMatcher("/api/**")
            .csrf(csrf -> csrf.disable())  // API 通常停用 CSRF
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers(HttpMethod.GET, "/api/products/**").permitAll()
                .anyRequest().authenticated()
            )
            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class)
            .exceptionHandling(ex -> ex
                .authenticationEntryPoint(new HttpStatusEntryPoint(HttpStatus.UNAUTHORIZED))
                .accessDeniedHandler((request, response, accessDeniedException) -> {
                    response.setStatus(HttpStatus.FORBIDDEN.value());
                    response.setContentType(MediaType.APPLICATION_JSON_VALUE);
                    response.getWriter().write("""
                        {"error": "Access Denied", "message": "您沒有權限存取此資源"}
                        """);
                })
            )
            .build();
    }
    
    @Bean
    public SecurityFilterChain webSecurityFilterChain(HttpSecurity http) throws Exception {
        return http
            .securityMatcher("/**")
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/", "/login", "/register", "/css/**", "/js/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/dashboard")
                .failureUrl("/login?error")
                .permitAll()
            )
            .logout(logout -> logout
                .logoutSuccessUrl("/login?logout")
                .invalidateHttpSession(true)
                .clearAuthentication(true)
                .deleteCookies("JSESSIONID")
            )
            .rememberMe(remember -> remember
                .key("uniqueAndSecretKey")
                .tokenValiditySeconds(86400 * 7)  // 7 天
            )
            .build();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);  // 強度提升至 12
    }
    
    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
}

// Spring Security 7.x CORS 設定
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .cors(cors -> cors.configurationSource(corsConfigurationSource()))
        // 其他設定...
        .build();
}

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowedOrigins(List.of("https://example.com"));
    config.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS"));
    config.setAllowedHeaders(List.of("*"));
    config.setAllowCredentials(true);
    config.setMaxAge(3600L);
    
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/api/**", config);
    return source;
}

// Spring Boot 4.x OAuth 2.0 Resource Server
@Configuration
@EnableWebSecurity
public class OAuth2ResourceServerConfig {
    
    @Bean
    public SecurityFilterChain resourceServerFilterChain(HttpSecurity http) 
            throws Exception {
        return http
            .securityMatcher("/api/**")
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt
                    .jwtAuthenticationConverter(jwtAuthenticationConverter())
                )
            )
            .build();
    }
    
    @Bean
    public JwtAuthenticationConverter jwtAuthenticationConverter() {
        JwtGrantedAuthoritiesConverter converter = new JwtGrantedAuthoritiesConverter();
        converter.setAuthorityPrefix("ROLE_");
        converter.setAuthoritiesClaimName("roles");
        
        JwtAuthenticationConverter jwtConverter = new JwtAuthenticationConverter();
        jwtConverter.setJwtGrantedAuthoritiesConverter(converter);
        return jwtConverter;
    }
}

// 【Breaking Change】Entity 定義更嚴格

// 舊版可省略的設定，新版建議明確標註
@Entity
@Table(name = "orders")
public class Order {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "order_number", nullable = false, unique = true)
    private String orderNumber;
    
    @Column(name = "total_amount", precision = 19, scale = 4)
    private BigDecimal totalAmount;
    
    @Enumerated(EnumType.STRING)
    @Column(name = "status", length = 20)
    private OrderStatus status;
    
    @CreationTimestamp
    @Column(name = "created_at", updatable = false)
    private Instant createdAt;
    
    @UpdateTimestamp
    @Column(name = "updated_at")
    private Instant updatedAt;
    
    // 【Breaking Change】雙向關聯需要明確設定
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();
    
    @ManyToOne(fetch = FetchType.LAZY)  // 明確指定 Lazy
    @JoinColumn(name = "customer_id", nullable = false)
    private Customer customer;
    
    // Constructors, Getters, Setters...
}

// 【Breaking Change】更嚴格的 Lazy Loading 處理

// 問題：LazyInitializationException
@Service
@Transactional(readOnly = true)
public class OrderService {
    
    // ❌ 會拋出 LazyInitializationException
    public OrderDto findById(Long id) {
        Order order = orderRepository.findById(id).orElseThrow();
        // 離開 Transaction 後存取 Lazy 屬性會失敗
        return toDto(order);  // 若在 toDto 中存取 items，會失敗
    }
    
    // ✅ 解決方案 1：使用 @EntityGraph
    public OrderDto findByIdWithItems(Long id) {
        Order order = orderRepository.findWithItemsById(id).orElseThrow();
        return toDto(order);
    }
    
    // ✅ 解決方案 2：使用 Projection
    public OrderSummary findSummaryById(Long id) {
        return orderRepository.findSummaryById(id).orElseThrow();
    }
}

// Repository 設定
public interface OrderRepository extends JpaRepository<Order, Long> {
    
    // 使用 @EntityGraph 載入關聯
    @EntityGraph(attributePaths = {"items", "customer"})
    Optional<Order> findWithItemsById(Long id);
    
    // 使用 Projection
    @Query("""
        SELECT new com.example.dto.OrderSummary(
            o.id, o.orderNumber, o.totalAmount, c.name
        )
        FROM Order o
        JOIN o.customer c
        WHERE o.id = :id
        """)
    Optional<OrderSummary> findSummaryById(@Param("id") Long id);
}

// Spring Data 2025.0.x 新增方法

public interface JpaRepository<T, ID> extends ... {
    
    // 新增：更安全的刪除方法
    void deleteAllByIdInBatch(Iterable<ID> ids);
    
    // 新增：支援 Scroll API（大量資料處理）
    Window<T> findBy(Specification<T> spec, ScrollPosition position, 
                     int limit, Sort sort);
}

// 使用範例：大量資料處理
@Service
public class DataExportService {
    
    private final OrderRepository orderRepository;
    
    public void exportAllOrders(Consumer<Order> processor) {
        ScrollPosition position = ScrollPosition.offset();
        Window<Order> window;
        
        do {
            window = orderRepository.findBy(
                Specification.where(null),
                position,
                100,  // batch size
                Sort.by("id")
            );
            
            window.getContent().forEach(processor);
            position = window.positionAt(window.getContent().size());
            
        } while (window.hasNext());
    }
}

// 【Breaking Change】查詢方法命名更嚴格

public interface CustomerRepository extends JpaRepository<Customer, Long> {
    
    // ❌ 舊版允許的模糊命名，新版可能產生警告
    List<Customer> findByName(String name);
    
    // ✅ 新版建議：更明確的方法命名
    List<Customer> findAllByNameContaining(String name);
    
    Optional<Customer> findFirstByEmail(String email);
    
    // 新增支援：Streamable 回傳類型
    Streamable<Customer> findAllByStatus(CustomerStatus status);
    
    // 新增支援：Slice 取代 Page（效能更好）
    Slice<Customer> findByRegistrationDateAfter(LocalDate date, Pageable pageable);
}

// Spring Boot 4.x Transaction 最佳實踐

@Service
public class OrderTransactionService {
    
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final NotificationService notificationService;
    
    // ✅ 明確標註 Transaction 屬性
    @Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.READ_COMMITTED,
        timeout = 30,
        rollbackFor = Exception.class
    )
    public Order createOrder(CreateOrderRequest request) {
        Order order = new Order();
        // 設定訂單資料...
        order = orderRepository.save(order);
        
        // 呼叫其他服務
        paymentService.processPayment(order);
        
        return order;
    }
    
    // ✅ 非同步操作需要新的 Transaction
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void sendNotification(Long orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        notificationService.send(order);
    }
    
    // ✅ 唯讀查詢優化
    @Transactional(readOnly = true)
    public List<Order> findOrders(OrderSearchCriteria criteria) {
        return orderRepository.findAll(criteria.toSpecification());
    }
}

// 【注意】Virtual Threads 下的 Transaction 處理

@Configuration
public class AsyncConfig {
    
    @Bean
    public AsyncTaskExecutor applicationTaskExecutor() {
        // 使用 Virtual Threads
        return new TaskExecutorAdapter(
            Executors.newVirtualThreadPerTaskExecutor()
        );
    }
}

@Service
public class AsyncOrderService {
    
    private final PlatformTransactionManager transactionManager;
    private final OrderRepository orderRepository;
    
    // ❌ 避免：在 Virtual Thread 中使用長時間 Transaction
    @Async
    public void processOrdersAsync(List<Long> orderIds) {
        // 這樣會長時間佔用 DB Connection
        orderIds.forEach(this::processOrder);
    }
    
    // ✅ 推薦：小批次處理，控制 Transaction 範圍
    @Async
    public void processOrdersAsyncBatched(List<Long> orderIds) {
        Lists.partition(orderIds, 10).forEach(batch -> {
            TransactionTemplate template = new TransactionTemplate(transactionManager);
            template.execute(status -> {
                batch.forEach(this::processOrder);
                return null;
            });
        });
    }
}

// 常見的 N+1 問題與解決方案

// ❌ 問題程式碼：產生 N+1 查詢
@Service
@Transactional(readOnly = true)
public class ReportService {
    
    public List<OrderReportDto> generateReport() {
        List<Order> orders = orderRepository.findAll();
        return orders.stream()
            .map(order -> new OrderReportDto(
                order.getId(),
                order.getItems().size(),  // N+1！每個訂單都會查詢
                order.getCustomer().getName()  // N+1！
            ))
            .toList();
    }
}

// ✅ 解決方案：使用 @EntityGraph 或 JOIN FETCH
public interface OrderRepository extends JpaRepository<Order, Long> {
    
    @EntityGraph(attributePaths = {"items", "customer"})
    @Query("SELECT o FROM Order o")
    List<Order> findAllWithItemsAndCustomer();
    
    // 或使用 JPQL
    @Query("""
        SELECT DISTINCT o FROM Order o
        LEFT JOIN FETCH o.items
        LEFT JOIN FETCH o.customer
        """)
    List<Order> findAllFetchAll();
}

# Spring Boot 4.x 設定變更對照

# 【Breaking Change】已移除或更名的設定
# 舊版：
spring:
  main:
    allow-bean-definition-overriding: true  # 預設 false，更嚴格

# 新版需明確啟用：
spring:
  main:
    allow-bean-definition-overriding: true

# 【Breaking Change】Server 設定調整
server:
  # 舊版
  # servlet:
  #   context-path: /api
  
  # 新版（架構調整）
  servlet:
    context-path: /api
    register-default-servlet: false  # 新增：預設 false
  
  # 新增：Virtual Threads 設定
  threads:
    virtual:
      enabled: true

# 【新增】Observability 設定
management:
  observations:
    enabled: true  # 預設啟用
  tracing:
    sampling:
      probability: 1.0
  otlp:
    tracing:
      endpoint: http://localhost:4318/v1/traces

# application.toml - Spring Boot 4.x 新增支援

[spring.application]
name = "my-application"

[spring.datasource]
url = "jdbc:postgresql://localhost:5432/mydb"
username = "app_user"
password = "${DB_PASSWORD}"
hikari.maximum-pool-size = 10
hikari.minimum-idle = 5

[server]
port = 8080
servlet.context-path = "/api"

[management.endpoints.web.exposure]
include = ["health", "info", "metrics", "prometheus"]

[logging.level]
root = "INFO"
"com.example" = "DEBUG"
"org.springframework.web" = "INFO"

// 【Breaking Change】Auto Configuration 條件變更

// 舊版：某些 Bean 會自動建立
// 新版：更嚴格的條件檢查

// 自定義 Auto Configuration
@AutoConfiguration
@ConditionalOnProperty(
    prefix = "app.feature",
    name = "enabled",
    havingValue = "true",
    matchIfMissing = false  // 新版預設 false
)
@ConditionalOnClass(FeatureService.class)
public class FeatureAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public FeatureService featureService(FeatureProperties properties) {
        return new DefaultFeatureService(properties);
    }
}

// 設定類別
@ConfigurationProperties(prefix = "app.feature")
@Validated
public record FeatureProperties(
    @NotBlank String apiKey,
    @Positive int timeout,
    @DefaultValue("3") int retryCount
) {}

// Spring Boot 4.x 排除 Auto Configuration 的方式

@SpringBootApplication(exclude = {
    DataSourceAutoConfiguration.class,
    SecurityAutoConfiguration.class
})
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

// 或透過設定檔
// application.yml
spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
      - org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration

# application.yml - 基礎設定
spring:
  application:
    name: order-service
  config:
    import: optional:configserver:http://config-server:8888

---
# application-kubernetes.yml - K8s 專用設定
spring:
  config:
    activate:
      on-profile: kubernetes
  cloud:
    kubernetes:
      config:
        enabled: true
        sources:
          - name: order-service
            namespace: ${NAMESPACE:default}
      secrets:
        enabled: true
        sources:
          - name: order-service-secrets

management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus
  health:
    livenessState:
      enabled: true
    readinessState:
      enabled: true
  endpoint:
    health:
      probes:
        enabled: true

# Kubernetes ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: order-service
  namespace: default
data:
  application.yml: |
    spring:
      datasource:
        url: jdbc:postgresql://postgres:5432/orders
    server:
      port: 8080

src/main/resources/
├── application.yml              # 共用設定
├── application-local.yml        # 本機開發
├── application-dev.yml          # 開發環境
├── application-sit.yml          # SIT 環境
├── application-uat.yml          # UAT 環境
├── application-prod.yml         # 正式環境
└── application-test.yml         # 測試用

# ❌ 避免：將敏感資訊寫在設定檔
spring:
  datasource:
    password: my-secret-password

# ✅ 推薦：使用環境變數
spring:
  datasource:
    password: ${DB_PASSWORD}

# ✅ 推薦：使用加密設定（搭配 Spring Cloud Config）
spring:
  datasource:
    password: '{cipher}AQBHOr...'

# ✅ 推薦：使用 Vault
spring:
  cloud:
    vault:
      host: vault.example.com
      port: 8200
      scheme: https
      authentication: KUBERNETES
      kubernetes:
        role: order-service

// Spring Boot 4.x 結構化日誌

// application.yml 設定
logging:
  structured:
    format: json  # 新增：結構化日誌格式
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} %5p [%X{traceId},%X{spanId}] --- [%15.15t] %-40.40logger{39} : %m%n"

// 使用 SLF4J 結構化日誌
@Slf4j
@Service
public class OrderService {
    
    public Order createOrder(CreateOrderRequest request) {
        log.atInfo()
            .addKeyValue("orderId", order.getId())
            .addKeyValue("customerId", request.getCustomerId())
            .addKeyValue("amount", order.getTotalAmount())
            .log("Order created successfully");
        
        return order;
    }
    
    public void processPayment(Order order) {
        try {
            // 處理付款...
            log.atInfo()
                .addKeyValue("orderId", order.getId())
                .addKeyValue("paymentMethod", order.getPaymentMethod())
                .log("Payment processed");
        } catch (PaymentException e) {
            log.atError()
                .addKeyValue("orderId", order.getId())
                .addKeyValue("errorCode", e.getErrorCode())
                .setCause(e)
                .log("Payment failed");
            throw e;
        }
    }
}

{
    "timestamp": "2026-01-30T10:30:00.123Z",
    "level": "INFO",
    "logger": "com.example.OrderService",
    "message": "Order created successfully",
    "traceId": "abc123",
    "spanId": "def456",
    "orderId": 12345,
    "customerId": 67890,
    "amount": 1500.00
}

<!-- Maven 相依 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing-bridge-otel</artifactId>
</dependency>
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-otlp</artifactId>
</dependency>

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  
  # Metrics 設定
  metrics:
    distribution:
      percentiles-histogram:
        http.server.requests: true
    tags:
      application: ${spring.application.name}
      environment: ${ENVIRONMENT:local}
  
  # Tracing 設定
  tracing:
    enabled: true
    sampling:
      probability: 1.0  # 開發環境 100%，生產環境調整
    propagation:
      type: W3C
  
  # OTLP Exporter 設定
  otlp:
    tracing:
      endpoint: http://otel-collector:4318/v1/traces
    metrics:
      endpoint: http://otel-collector:4318/v1/metrics

// 使用 Micrometer 建立自定義指標

@Component
public class OrderMetrics {
    
    private final Counter orderCreatedCounter;
    private final Timer orderProcessingTimer;
    private final AtomicInteger activeOrdersGauge;
    
    public OrderMetrics(MeterRegistry registry) {
        this.orderCreatedCounter = Counter.builder("orders.created.total")
            .description("Total number of orders created")
            .tag("application", "order-service")
            .register(registry);
        
        this.orderProcessingTimer = Timer.builder("orders.processing.duration")
            .description("Order processing duration")
            .publishPercentiles(0.5, 0.95, 0.99)
            .register(registry);
        
        this.activeOrdersGauge = registry.gauge("orders.active.count",
            new AtomicInteger(0));
    }
    
    public void recordOrderCreated(String orderType) {
        orderCreatedCounter.increment();
    }
    
    public <T> T recordOrderProcessing(Supplier<T> operation) {
        return orderProcessingTimer.record(operation);
    }
    
    public void updateActiveOrders(int count) {
        activeOrdersGauge.set(count);
    }
}

// 使用範例
@Service
public class OrderService {
    
    private final OrderMetrics metrics;
    
    public Order createOrder(CreateOrderRequest request) {
        return metrics.recordOrderProcessing(() -> {
            Order order = // 建立訂單...
            metrics.recordOrderCreated(order.getType());
            return order;
        });
    }
}

// 自定義 Span

@Service
public class PaymentService {
    
    private final Tracer tracer;
    private final PaymentGateway gateway;
    
    public PaymentService(Tracer tracer, PaymentGateway gateway) {
        this.tracer = tracer;
        this.gateway = gateway;
    }
    
    public PaymentResult processPayment(Order order) {
        Span span = tracer.nextSpan()
            .name("payment-processing")
            .tag("orderId", order.getId().toString())
            .tag("amount", order.getTotalAmount().toString())
            .start();
        
        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
            // 呼叫外部付款閘道
            PaymentResult result = gateway.process(order);
            
            span.tag("paymentId", result.getPaymentId());
            span.tag("status", result.getStatus().name());
            
            return result;
        } catch (Exception e) {
            span.error(e);
            throw e;
        } finally {
            span.end();
        }
    }
}

# 建議監控的關鍵指標

# 1. Latency（延遲）
# - http_server_requests_seconds_bucket
# - P50, P95, P99 回應時間

# 2. Traffic（流量）
# - http_server_requests_seconds_count
# - 每秒請求數（RPS）

# 3. Errors（錯誤）
# - http_server_requests_seconds_count{status="5xx"}
# - 錯誤率

# 4. Saturation（飽和度）
# - jvm_memory_used_bytes
# - hikaricp_connections_active
# - 資源使用率

// 自定義健康檢查

@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    
    private final DataSource dataSource;
    
    @Override
    public Health health() {
        try (Connection conn = dataSource.getConnection()) {
            if (conn.isValid(5)) {
                return Health.up()
                    .withDetail("database", "PostgreSQL")
                    .withDetail("connection", "valid")
                    .build();
            }
        } catch (SQLException e) {
            return Health.down()
                .withException(e)
                .build();
        }
        return Health.unknown().build();
    }
}

// 外部服務健康檢查
@Component
public class ExternalApiHealthIndicator implements HealthIndicator {
    
    private final RestClient restClient;
    
    @Override
    public Health health() {
        try {
            ResponseEntity<Void> response = restClient.get()
                .uri("/health")
                .retrieve()
                .toBodilessEntity();
            
            if (response.getStatusCode().is2xxSuccessful()) {
                return Health.up().build();
            }
            return Health.down()
                .withDetail("status", response.getStatusCode())
                .build();
        } catch (Exception e) {
            return Health.down().withException(e).build();
        }
    }
}

// 【Breaking Change】測試註解調整

// 舊版
@RunWith(SpringRunner.class)
@SpringBootTest

// 新版（JUnit 5 為標準）
@SpringBootTest
class MyApplicationTests {
    // JUnit 5 不需要 @RunWith
}

// 【新增】更細緻的測試切片
@WebMvcTest(OrderController.class)
@AutoConfigureMockMvc
@Import(SecurityConfig.class)  // 需要時才引入 Security
class OrderControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private OrderService orderService;
    
    @Test
    void shouldReturnOrder() throws Exception {
        // ...
    }
}

// Spring Boot 4.x MockMvc 新功能

@WebMvcTest(OrderController.class)
class OrderControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    void createOrder_shouldReturnCreated() throws Exception {
        CreateOrderRequest request = new CreateOrderRequest(
            "CUST001", 
            List.of(new OrderItem("PROD001", 2))
        );
        
        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.orderId").exists())
            .andExpect(jsonPath("$.status").value("PENDING"))
            // 新增：更精確的 JSON 驗證
            .andExpect(jsonPath("$.items").isArray())
            .andExpect(jsonPath("$.items", hasSize(1)))
            // 新增：Response Header 驗證
            .andExpect(header().exists("Location"))
            .andExpect(header().string("Location", 
                containsString("/api/orders/")));
    }
    
    // 新增：WebTestClient 風格（即使是 MVC 也可用）
    @Autowired
    private WebTestClient webTestClient;
    
    @Test
    void getOrder_withWebTestClient() {
        webTestClient.get()
            .uri("/api/orders/{id}", 1L)
            .exchange()
            .expectStatus().isOk()
            .expectBody(OrderDto.class)
            .value(order -> {
                assertThat(order.getId()).isEqualTo(1L);
                assertThat(order.getStatus()).isEqualTo(OrderStatus.PENDING);
            });
    }
}

// Security 測試修復

// ❌ 舊版測試可能失敗
@WebMvcTest(OrderController.class)
class OrderControllerTest {
    @Test
    void shouldReturnOrder() throws Exception {
        // 因為 Security 預設啟用，會回傳 401
    }
}

// ✅ 解決方案 1：停用 Security
@WebMvcTest(OrderController.class)
@AutoConfigureMockMvc(addFilters = false)
class OrderControllerTest {
    // ...
}

// ✅ 解決方案 2：模擬認證使用者
@WebMvcTest(OrderController.class)
class OrderControllerTest {
    
    @Test
    @WithMockUser(username = "testuser", roles = {"USER"})
    void shouldReturnOrder() throws Exception {
        // ...
    }
    
    @Test
    void adminEndpoint_withAdminRole() throws Exception {
        mockMvc.perform(get("/api/admin/orders")
                .with(user("admin").roles("ADMIN")))
            .andExpect(status().isOk());
    }
}

// ✅ 解決方案 3：使用 @TestConfiguration
@WebMvcTest(OrderController.class)
@Import(TestSecurityConfig.class)
class OrderControllerTest {
    // ...
}

@TestConfiguration
class TestSecurityConfig {
    @Bean
    public SecurityFilterChain testFilterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth.anyRequest().permitAll())
            .csrf(csrf -> csrf.disable())
            .build();
    }
}

// 1. 先確保所有測試在舊版通過
// mvn test

// 2. 升級後執行測試，記錄失敗項目
// mvn test -Dmaven.test.failure.ignore=true

// 3. 逐一修復失敗的測試

// 4. 新增針對新功能的測試

// 整合測試範例（使用 TestContainers）
@SpringBootTest
@Testcontainers
class OrderServiceIntegrationTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }
    
    @Autowired
    private OrderService orderService;
    
    @Test
    void createOrder_shouldPersistToDatabase() {
        CreateOrderRequest request = new CreateOrderRequest(/* ... */);
        
        Order order = orderService.createOrder(request);
        
        assertThat(order.getId()).isNotNull();
        assertThat(orderService.findById(order.getId())).isPresent();
    }
}

// 使用 Spring Cloud Contract 進行契約測試

// 1. 定義契約（Groovy DSL）
// contracts/shouldReturnOrder.groovy
Contract.make {
    description "should return order by id"
    request {
        method GET()
        url "/api/orders/1"
        headers {
            contentType applicationJson()
        }
    }
    response {
        status OK()
        headers {
            contentType applicationJson()
        }
        body([
            id: 1,
            orderNumber: $(regex('[A-Z]{3}[0-9]{6}')),
            status: "PENDING",
            totalAmount: $(anyDouble())
        ])
    }
}

// 2. 產生測試基礎類別
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@AutoConfigureMockMvc
abstract class ContractTestBase {
    
    @Autowired
    MockMvc mockMvc;
    
    @MockBean
    OrderService orderService;
    
    @BeforeEach
    void setup() {
        Order mockOrder = new Order(1L, "ABC123456", OrderStatus.PENDING, 
            new BigDecimal("100.00"));
        when(orderService.findById(1L)).thenReturn(Optional.of(mockOrder));
        
        RestAssuredMockMvc.mockMvc(mockMvc);
    }
}

// PoC 專案結構建議

// 1. 建立獨立的 PoC 分支
// git checkout -b feature/spring-boot-4-poc

// 2. 更新 pom.xml
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.0.0</version>
</parent>

<properties>
    <java.version>21</java.version>
</properties>

// 3. 執行編譯，記錄錯誤
// mvn clean compile 2>&1 | tee compile-errors.log

// 4. 逐一修復編譯錯誤

// 5. 執行測試
// mvn test 2>&1 | tee test-results.log

// 6. 產生升版影響報告

#!/bin/bash
# rollback.sh - Spring Boot 升版 Rollback 腳本

set -e

# 參數
APP_NAME=${1:-order-service}
PREVIOUS_VERSION=${2:-3.4.1}
NAMESPACE=${3:-production}

echo "=== 開始 Rollback: $APP_NAME 至版本 $PREVIOUS_VERSION ==="

# 1. 確認目前版本
CURRENT_VERSION=$(kubectl get deployment $APP_NAME -n $NAMESPACE \
    -o jsonpath='{.spec.template.spec.containers[0].image}' | cut -d: -f2)
echo "目前版本: $CURRENT_VERSION"

# 2. 執行 Rollback
kubectl set image deployment/$APP_NAME \
    $APP_NAME=$APP_NAME:$PREVIOUS_VERSION \
    -n $NAMESPACE

# 3. 等待 Rollback 完成
kubectl rollout status deployment/$APP_NAME -n $NAMESPACE --timeout=300s

# 4. 驗證
NEW_VERSION=$(kubectl get deployment $APP_NAME -n $NAMESPACE \
    -o jsonpath='{.spec.template.spec.containers[0].image}' | cut -d: -f2)
echo "Rollback 完成，目前版本: $NEW_VERSION"

# 5. 健康檢查
echo "執行健康檢查..."
sleep 30
HEALTH=$(kubectl exec -it deploy/$APP_NAME -n $NAMESPACE -- \
    curl -s localhost:8080/actuator/health | jq -r '.status')

if [ "$HEALTH" == "UP" ]; then
    echo "✅ Rollback 成功，服務健康"
else
    echo "❌ 警告：服務狀態異常，請立即檢查"
    exit 1
fi

// Jenkinsfile - Spring Boot 升版 Pipeline

pipeline {
    agent any
    
    environment {
        JAVA_HOME = tool 'JDK21'
        MAVEN_HOME = tool 'Maven3.9'
        PATH = "${JAVA_HOME}/bin:${MAVEN_HOME}/bin:${PATH}"
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Build & Test') {
            steps {
                sh 'mvn clean verify'
            }
            post {
                always {
                    junit '**/target/surefire-reports/*.xml'
                    jacoco execPattern: '**/target/jacoco.exec'
                }
            }
        }
        
        stage('Security Scan') {
            steps {
                sh 'mvn dependency-check:check'
            }
        }
        
        stage('Build Image') {
            steps {
                sh '''
                    docker build -t ${IMAGE_NAME}:${BUILD_NUMBER} .
                    docker push ${IMAGE_NAME}:${BUILD_NUMBER}
                '''
            }
        }
        
        stage('Deploy to SIT') {
            steps {
                sh '''
                    kubectl set image deployment/${APP_NAME} \
                        ${APP_NAME}=${IMAGE_NAME}:${BUILD_NUMBER} \
                        -n sit
                '''
            }
        }
        
        stage('Integration Test') {
            steps {
                sh 'mvn verify -Pintegration-test'
            }
        }
        
        stage('Deploy to UAT') {
            when {
                branch 'release/*'
            }
            steps {
                input message: '確認部署至 UAT?'
                sh '''
                    kubectl set image deployment/${APP_NAME} \
                        ${APP_NAME}=${IMAGE_NAME}:${BUILD_NUMBER} \
                        -n uat
                '''
            }
        }
        
        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            steps {
                input message: '確認部署至 Production?'
                sh '''
                    # Canary Deployment
                    kubectl set image deployment/${APP_NAME}-canary \
                        ${APP_NAME}=${IMAGE_NAME}:${BUILD_NUMBER} \
                        -n production
                '''
            }
        }
    }
    
    post {
        failure {
            slackSend channel: '#alerts',
                color: 'danger',
                message: "Build Failed: ${env.JOB_NAME} ${env.BUILD_NUMBER}"
        }
    }
}

// 陷阱：Bean 初始化順序

@Component
public class MyBean {
    
    private final MyDependency dependency;
    
    // 問：以下哪個先執行？
    // A) 建構子
    // B) @Autowired setter
    // C) @PostConstruct
    // D) InitializingBean.afterPropertiesSet()
    
    public MyBean(MyDependency dependency) {
        this.dependency = dependency;
        System.out.println("1. Constructor");
    }
    
    @Autowired
    public void setOtherDependency(OtherDependency other) {
        System.out.println("2. Autowired setter");
    }
    
    @PostConstruct
    public void init() {
        System.out.println("3. PostConstruct");
    }
    
    // 若實作 InitializingBean
    // public void afterPropertiesSet() {
    //     System.out.println("4. afterPropertiesSet");
    // }
    
    // 答案：A → B → C → D
}

// 陷阱：Transaction 傳播行為

@Service
public class OrderService {
    
    @Autowired
    private PaymentService paymentService;
    
    @Transactional
    public void createOrder() {
        // 問：以下呼叫是否在同一個 Transaction 中？
        paymentService.processPayment();  // REQUIRED
        paymentService.sendNotification(); // REQUIRES_NEW
    }
}

@Service
public class PaymentService {
    
    @Transactional(propagation = Propagation.REQUIRED)
    public void processPayment() {
        // 與 createOrder() 同一個 Transaction
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void sendNotification() {
        // 建立新的 Transaction
        // 若這裡失敗，不會影響 processPayment()
    }
}

// 陷阱：Security 設定順序

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    // 問：以下設定，/api/public/** 能否匿名存取？
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .anyRequest().authenticated()  // ❌ 這行先執行
                .requestMatchers("/api/public/**").permitAll()
            )
            .build();
    }
    
    // 正確寫法：
    @Bean
    public SecurityFilterChain correctFilterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()  // ✅ 更具體的規則在前
                .anyRequest().authenticated()
            )
            .build();
    }
}

// 模擬試題 1
// 問：以下程式碼，當呼叫 service.process() 時，會輸出什麼？

@Service
public class MyService {
    
    @Autowired
    private MyService self;
    
    public void process() {
        System.out.println("1");
        self.innerProcess();
        System.out.println("3");
    }
    
    @Transactional
    public void innerProcess() {
        System.out.println("2");
    }
}

// A) 1, 2, 3（Transaction 生效）
// B) 1, 2, 3（Transaction 不生效）
// C) 編譯錯誤
// D) 執行時錯誤

// 答案：A
// 解釋：透過注入自己（self），可以讓 AOP 代理生效

// ---

// 模擬試題 2
// 問：Spring Boot 4.x 最低支援的 Java 版本是？

// A) Java 17
// B) Java 21
// C) Java 11
// D) Java 8

// 答案：B（Java 21）

// ---

// 模擬試題 3
// 問：以下哪個不是 Spring Security 7.x 的有效設定方式？

// A) 實作 WebSecurityConfigurerAdapter
// B) 定義 SecurityFilterChain Bean
// C) 使用 @EnableMethodSecurity
// D) 使用 Lambda DSL

// 答案：A（WebSecurityConfigurerAdapter 已在 Spring Security 7.x 中移除）

mvn clean compile                    # 編譯
mvn test                             # 執行測試
mvn verify                           # 完整驗證
mvn dependency:tree                  # 檢視相依樹
mvn versions:display-dependency-updates  # 檢查更新

./gradlew clean build               # 建置
./gradlew test                      # 執行測試
./gradlew dependencies              # 檢視相依

docker build -t myapp:4.0 .         # 建置映像
docker run -p 8080:8080 myapp:4.0   # 執行容器

kubectl set image deployment/myapp myapp=myapp:4.0  # 更新映像
kubectl rollout status deployment/myapp             # 檢查部署狀態
kubectl rollout undo deployment/myapp               # Rollback

curl localhost:8080/actuator/health   # 健康檢查
curl localhost:8080/actuator/info     # 應用資訊
curl localhost:8080/actuator/metrics  # 指標