// 傳統方式 - 緊密耦合
public class UserService {
    private UserDAO userDAO = new UserDAOImpl(); // 直接創建依賴
    
    public User getUser(Long id) {
        return userDAO.findById(id);
    }
}

// Spring 方式 - 鬆散耦合
@Service
public class UserService {
    @Autowired
    private UserDAO userDAO; // Spring 自動注入依賴
    
    public User getUser(Long id) {
        return userDAO.findById(id);
    }
}

public class OrderService {
    private PaymentService paymentService;
    private EmailService emailService;
    
    public OrderService() {
        // 物件自己創建依賴 - 控制權在物件本身
        this.paymentService = new PaymentServiceImpl();
        this.emailService = new EmailServiceImpl();
    }
}

@Service
public class OrderService {
    private final PaymentService paymentService;
    private final EmailService emailService;
    
    // 控制權交給 Spring 容器
    public OrderService(PaymentService paymentService, EmailService emailService) {
        this.paymentService = paymentService;
        this.emailService = emailService;
    }
}

@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    // 推薦方式：建構子注入
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

@Service
public class UserService {
    private UserRepository userRepository;
    private EmailService emailService;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private EmailService emailService;
}

@Component
public class UserService {
    // Spring 會自動創建 UserService 的實例
}

@Service
public class OrderService {
    // @Service 是 @Component 的特化註解
}

@Repository
public class UserRepository {
    // @Repository 是 @Component 的特化註解
}

@Controller
public class UserController {
    // @Controller 是 @Component 的特化註解
}

@Configuration
public class AppConfig {
    
    @Bean
    public UserService userService() {
        return new UserService();
    }
    
    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
}

// 註解配置
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// XML 配置
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

// Web 應用程式
// 通常由 Spring Boot 自動配置

// 實際專案中的服務層設計
@Service
@Transactional
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final EmailService emailService;
    
    public OrderService(OrderRepository orderRepository,
                       PaymentService paymentService,
                       EmailService emailService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
        this.emailService = emailService;
    }
    
    public Order createOrder(OrderRequest request) {
        // 1. 創建訂單
        Order order = new Order(request);
        order = orderRepository.save(order);
        
        // 2. 處理付款
        Payment payment = paymentService.processPayment(order);
        
        // 3. 發送確認郵件
        emailService.sendOrderConfirmation(order);
        
        return order;
    }
}

public interface BeanFactory {
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    // ... 其他方法
}

// ApplicationContext 的額外功能
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// 1. 國際化支援
String message = context.getMessage("welcome.message", null, Locale.getDefault());

// 2. 事件發布
context.publishEvent(new UserRegisteredEvent(user));

// 3. 資源載入
Resource resource = context.getResource("classpath:config.properties");

@Configuration
@ComponentScan(basePackages = "com.tutorial")
@EnableAutoConfiguration
public class AppConfig {
}

// 各種 Component 註解
@Component        // 通用元件
@Service         // 服務層
@Repository      // 資料存取層
@Controller      // 控制層
@RestController  // REST 控制層

@Service
@Scope("singleton")    // 預設，單例
public class UserService { }

@Service
@Scope("prototype")    // 每次請求新實例
public class OrderService { }

@Controller
@Scope("session")      // Web 環境，每個 session 一個實例
public class UserController { }

@Configuration
public class DatabaseConfig {
    
    @Bean
    @Primary
    public DataSource primaryDataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/primary");
        dataSource.setUsername("user");
        dataSource.setPassword("password");
        return dataSource;
    }
    
    @Bean("secondaryDS")
    public DataSource secondaryDataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/secondary");
        return dataSource;
    }
    
    @Bean
    @Profile("development")
    public UserService devUserService() {
        return new DevUserService();
    }
    
    @Bean
    @Profile("production")
    public UserService prodUserService() {
        return new ProdUserService();
    }
}

@Service
public class NotificationService {
    private final List<NotificationProvider> providers;
    
    // 注入所有 NotificationProvider 實現
    public NotificationService(List<NotificationProvider> providers) {
        this.providers = providers;
    }
}

@Component
@ConditionalOnProperty(name = "email.enabled", havingValue = "true")
public class EmailNotificationProvider implements NotificationProvider {
    // 只有在配置 email.enabled=true 時才會創建
}

@Component
@ConditionalOnClass(SmsClient.class)
public class SmsNotificationProvider implements NotificationProvider {
    // 只有在 classpath 中存在 SmsClient 類別時才會創建
}

public interface PaymentProcessor {
    void process(Payment payment);
}

@Component
@Primary
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) {
        // 信用卡處理邏輯
    }
}

@Component
@Qualifier("paypal")
public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) {
        // PayPal 處理邏輯
    }
}

@Service
public class OrderService {
    private final PaymentProcessor defaultProcessor;
    private final PaymentProcessor paypalProcessor;
    
    public OrderService(PaymentProcessor defaultProcessor,
                       @Qualifier("paypal") PaymentProcessor paypalProcessor) {
        this.defaultProcessor = defaultProcessor;    // 注入 @Primary
        this.paypalProcessor = paypalProcessor;      // 注入指定的 Qualifier
    }
}

@Component
public class DatabaseConnectionBean implements BeanNameAware, 
                                             BeanFactoryAware,
                                             ApplicationContextAware,
                                             InitializingBean,
                                             DisposableBean {
    
    private String beanName;
    private BeanFactory beanFactory;
    private ApplicationContext applicationContext;
    
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("BeanNameAware: " + name);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("BeanFactoryAware 被調用");
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("ApplicationContextAware 被調用");
    }
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("@PostConstruct 被調用");
        // 初始化資料庫連接
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean.afterPropertiesSet 被調用");
    }
    
    @PreDestroy
    public void preDestroy() {
        System.out.println("@PreDestroy 被調用");
        // 清理資源
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean.destroy 被調用");
    }
}

@Component
public class ApplicationEventListener {
    
    @EventListener
    public void handleContextRefreshed(ContextRefreshedEvent event) {
        System.out.println("ApplicationContext 已刷新");
    }
    
    @EventListener
    public void handleContextStarted(ContextStartedEvent event) {
        System.out.println("ApplicationContext 已啟動");
    }
    
    @EventListener
    public void handleContextStopped(ContextStoppedEvent event) {
        System.out.println("ApplicationContext 已停止");
    }
}

// 自定義事件
public class UserRegisteredEvent extends ApplicationEvent {
    private final User user;
    
    public UserRegisteredEvent(Object source, User user) {
        super(source);
        this.user = user;
    }
    
    public User getUser() {
        return user;
    }
}

// 事件發布者
@Service
public class UserService {
    private final ApplicationEventPublisher eventPublisher;
    
    public UserService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public User registerUser(UserRegistrationRequest request) {
        User user = new User(request);
        // 保存用戶邏輯...
        
        // 發布事件
        eventPublisher.publishEvent(new UserRegisteredEvent(this, user));
        
        return user;
    }
}

// 事件監聽器
@Component
public class UserEventHandler {
    
    @EventListener
    @Async
    public void handleUserRegistered(UserRegisteredEvent event) {
        User user = event.getUser();
        // 發送歡迎郵件
        sendWelcomeEmail(user);
    }
    
    @EventListener
    @Order(1)
    public void updateUserStatistics(UserRegisteredEvent event) {
        // 更新用戶統計
    }
}

// 完整的服務配置範例
@Configuration
@EnableScheduling
@EnableAsync
public class ServiceConfig {
    
    @Bean
    @ConfigurationProperties(prefix = "app.cache")
    public CacheProperties cacheProperties() {
        return new CacheProperties();
    }
    
    @Bean
    @ConditionalOnProperty(name = "app.cache.enabled", havingValue = "true")
    public CacheManager cacheManager(CacheProperties properties) {
        RedisCacheManager.Builder builder = RedisCacheManager
            .RedisCacheManagerBuilder
            .fromConnectionFactory(redisConnectionFactory())
            .cacheDefaults(cacheConfiguration(properties));
            
        return builder.build();
    }
    
    @Bean
    @Profile("!test")
    public RedisConnectionFactory redisConnectionFactory() {
        LettuceConnectionFactory factory = new LettuceConnectionFactory();
        factory.setHostName("localhost");
        factory.setPort(6379);
        return factory;
    }
}

@Component
@Scope("singleton") // 或 @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class UserService {
    private int counter = 0; // 注意：線程安全問題
    
    public void incrementCounter() {
        counter++; // 在多線程環境下不安全
    }
}

// 正確的 singleton 設計
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    // 無狀態方法，線程安全
    public User findById(Long id) {
        return userRepository.findById(id);
    }
}

@Component
@Scope("prototype")
public class OrderProcessor {
    private Order currentOrder;
    private List<OrderItem> items = new ArrayList<>();
    
    public void setOrder(Order order) {
        this.currentOrder = order;
    }
    
    public void addItem(OrderItem item) {
        items.add(item);
    }
}

// 使用 prototype Bean
@Service
public class OrderService {
    private final ApplicationContext applicationContext;
    
    public OrderService(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
    
    public Order processOrder(OrderRequest request) {
        // 每次獲取新的 OrderProcessor 實例
        OrderProcessor processor = applicationContext.getBean(OrderProcessor.class);
        
        Order order = new Order(request);
        processor.setOrder(order);
        
        for (OrderItemRequest itemRequest : request.getItems()) {
            processor.addItem(new OrderItem(itemRequest));
        }
        
        return processor.process();
    }
}

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestScopedBean {
    private String requestId = UUID.randomUUID().toString();
    
    public String getRequestId() {
        return requestId;
    }
}

@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class UserSession {
    private User currentUser;
    private LocalDateTime loginTime;
    
    public void login(User user) {
        this.currentUser = user;
        this.loginTime = LocalDateTime.now();
    }
    
    public boolean isLoggedIn() {
        return currentUser != null;
    }
}

@Component
public class DatabaseService {
    
    private DataSource dataSource;
    
    // 方法1：使用 @PostConstruct
    @PostConstruct
    public void initialize() {
        System.out.println("DatabaseService 正在初始化...");
        // 初始化資料庫連接池
        setupConnectionPool();
    }
    
    // 方法2：實現 InitializingBean 接口
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean.afterPropertiesSet 被調用");
        validateConfiguration();
    }
    
    private void setupConnectionPool() {
        // 設定連接池邏輯
    }
    
    private void validateConfiguration() {
        // 驗證配置邏輯
    }
}

// 方法3：Java 配置中指定初始化方法
@Configuration
public class DatabaseConfig {
    
    @Bean(initMethod = "init", destroyMethod = "cleanup")
    public CustomDatabaseService customDatabaseService() {
        return new CustomDatabaseService();
    }
}

public class CustomDatabaseService {
    
    public void init() {
        System.out.println("自定義初始化方法被調用");
    }
    
    public void cleanup() {
        System.out.println("自定義清理方法被調用");
    }
}

@Component
public class ResourceManager {
    
    private ExecutorService executorService;
    
    @PostConstruct
    public void setUp() {
        executorService = Executors.newFixedThreadPool(10);
    }
    
    // 方法1：使用 @PreDestroy
    @PreDestroy
    public void shutdown() {
        System.out.println("ResourceManager 正在關閉...");
        if (executorService != null && !executorService.isShutdown()) {
            executorService.shutdown();
            try {
                if (!executorService.awaitTermination(30, TimeUnit.SECONDS)) {
                    executorService.shutdownNow();
                }
            } catch (InterruptedException e) {
                executorService.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
    
    // 方法2：實現 DisposableBean 接口
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean.destroy 被調用");
        // 額外的清理邏輯
    }
}

// 全局延遲初始化
@Configuration
@Lazy
public class AppConfig {
    // 所有 Bean 都會延遲初始化
}

// 單個 Bean 延遲初始化
@Service
@Lazy
public class HeavyService {
    
    @PostConstruct
    public void init() {
        System.out.println("HeavyService 被初始化了"); // 只有在第一次使用時才會輸出
    }
}

// 在依賴注入時指定延遲
@Controller
public class UserController {
    
    private final UserService userService;
    
    // 只有在第一次調用 userService 時才會初始化
    public UserController(@Lazy UserService userService) {
        this.userService = userService;
    }
}

@Configuration
public class ConditionalConfig {
    
    @Bean
    @ConditionalOnProperty(name = "email.provider", havingValue = "gmail")
    public EmailService gmailEmailService() {
        return new GmailEmailService();
    }
    
    @Bean
    @ConditionalOnProperty(name = "email.provider", havingValue = "outlook")
    public EmailService outlookEmailService() {
        return new OutlookEmailService();
    }
    
    @Bean
    @ConditionalOnMissingBean
    public EmailService defaultEmailService() {
        return new DefaultEmailService();
    }
    
    @Bean
    @ConditionalOnClass(Redis.class)
    public CacheService redisCacheService() {
        return new RedisCacheService();
    }
    
    @Bean
    @ConditionalOnMissingClass("redis.clients.jedis.Jedis")
    public CacheService memoryCacheService() {
        return new MemoryCacheService();
    }
}

// 自定義條件類
public class WindowsCondition implements Condition {
    
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        String osName = environment.getProperty("os.name");
        return osName != null && osName.toLowerCase().contains("windows");
    }
}

@Configuration
public class OSSpecificConfig {
    
    @Bean
    @Conditional(WindowsCondition.class)
    public FileService windowsFileService() {
        return new WindowsFileService();
    }
    
    @Bean
    @ConditionalOnProperty(name = "os.name", havingValue = "Linux")
    public FileService linuxFileService() {
        return new LinuxFileService();
    }
}

@Configuration
public class EnvironmentConfig {
    
    @Bean
    @Profile("development")
    public DataSource devDataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:h2:mem:devdb")
            .username("sa")
            .password("")
            .build();
    }
    
    @Bean
    @Profile("test")
    public DataSource testDataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:h2:mem:testdb")
            .username("sa")
            .password("")
            .build();
    }
    
    @Bean
    @Profile("production")
    public DataSource prodDataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:mysql://prod-server:3306/proddb")
            .username("${db.username}")
            .password("${db.password}")
            .build();
    }
}

// 啟動時指定 Profile
// java -Dspring.profiles.active=development -jar app.jar
// 或在 application.properties 中設定：spring.profiles.active=development

@Component
@Profile("!production")  // 除了 production 環境外都會創建
public class DebugService {
    // 除錯服務只在非正式環境中可用
}

// 實現 FactoryBean 接口
@Component
public class ConnectionFactoryBean implements FactoryBean<Connection> {
    
    @Value("${database.url}")
    private String url;
    
    @Value("${database.username}")
    private String username;
    
    @Value("${database.password}")
    private String password;
    
    @Override
    public Connection getObject() throws Exception {
        return DriverManager.getConnection(url, username, password);
    }
    
    @Override
    public Class<?> getObjectType() {
        return Connection.class;
    }
    
    @Override
    public boolean isSingleton() {
        return false; // 每次請求都創建新的連接
    }
}

// 複雜物件的 Factory
@Component
public class HttpClientFactoryBean implements FactoryBean<CloseableHttpClient> {
    
    @Override
    public CloseableHttpClient getObject() throws Exception {
        RequestConfig requestConfig = RequestConfig.custom()
            .setConnectionRequestTimeout(5000)
            .setConnectTimeout(5000)
            .setSocketTimeout(30000)
            .build();
            
        return HttpClients.custom()
            .setDefaultRequestConfig(requestConfig)
            .setMaxConnTotal(100)
            .setMaxConnPerRoute(20)
            .build();
    }
    
    @Override
    public Class<?> getObjectType() {
        return CloseableHttpClient.class;
    }
    
    @Override
    public boolean isSingleton() {
        return true;
    }
}

// 完整的服務配置範例
@Configuration
@EnableConfigurationProperties(AppProperties.class)
public class ServiceConfiguration {
    
    private final AppProperties appProperties;
    
    public ServiceConfiguration(AppProperties appProperties) {
        this.appProperties = appProperties;
    }
    
    @Bean
    @Scope("prototype")
    public OrderProcessor orderProcessor() {
        return new OrderProcessor();
    }
    
    @Bean
    @ConditionalOnProperty(name = "app.features.cache.enabled", havingValue = "true")
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("users", "orders", "products");
    }
    
    @Bean
    @Profile("!test")
    @Scope(value = "singleton", proxyMode = ScopedProxyMode.TARGET_CLASS)
    public EmailService emailService() {
        if (appProperties.getEmail().getProvider().equals("smtp")) {
            return new SmtpEmailService(appProperties.getEmail());
        } else {
            return new ApiEmailService(appProperties.getEmail());
        }
    }
    
    @Bean
    @Profile("test")
    public EmailService mockEmailService() {
        return new MockEmailService();
    }
}

@ConfigurationProperties(prefix = "app")
@Data
public class AppProperties {
    private Features features = new Features();
    private Email email = new Email();
    
    @Data
    public static class Features {
        private Cache cache = new Cache();
        
        @Data
        public static class Cache {
            private boolean enabled = false;
        }
    }
    
    @Data
    public static class Email {
        private String provider = "smtp";
        private String host;
        private int port = 587;
        private String username;
        private String password;
    }
}

@Aspect
@Component
public class LoggingAspect {
    
    private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);
    
    @Before("execution(* com.tutorial.service.*.*(..))")
    public void logMethodEntry(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getTarget().getClass().getSimpleName();
        Object[] args = joinPoint.getArgs();
        
        logger.info("進入方法: {}.{}, 參數: {}", className, methodName, Arrays.toString(args));
    }
    
    @Before("@annotation(secured)")
    public void checkSecurity(JoinPoint joinPoint, Secured secured) {
        String role = secured.value();
        // 檢查當前用戶是否有指定角色
        if (!SecurityContextHolder.getContext().getAuthentication().getAuthorities()
            .stream().anyMatch(auth -> auth.getAuthority().equals(role))) {
            throw new AccessDeniedException("權限不足: 需要 " + role + " 角色");
        }
    }
}

@Aspect
@Component
public class AuditAspect {
    
    @Autowired
    private AuditService auditService;
    
    @After("execution(* com.tutorial.service.UserService.create*(..))")
    public void auditUserCreation(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        if (args.length > 0 && args[0] instanceof User) {
            User user = (User) args[0];
            auditService.logUserCreation(user.getId(), getCurrentUser());
        }
    }
    
    @AfterReturning(value = "execution(* com.tutorial.service.*Service.save*(..))", 
                   returning = "result")
    public void logSuccessfulSave(JoinPoint joinPoint, Object result) {
        logger.info("成功保存: {}, 結果: {}", joinPoint.getSignature().getName(), result);
    }
    
    @AfterThrowing(value = "execution(* com.tutorial.service.*.*(..))", 
                  throwing = "exception")
    public void logException(JoinPoint joinPoint, Exception exception) {
        logger.error("方法 {} 拋出異常: {}", joinPoint.getSignature().getName(), 
                    exception.getMessage(), exception);
    }
}

@Aspect
@Component
public class PerformanceAspect {
    
    private static final Logger logger = LoggerFactory.getLogger(PerformanceAspect.class);
    
    @Around("execution(* com.tutorial.service.*.*(..))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        
        try {
            // 執行目標方法
            Object result = joinPoint.proceed();
            
            long endTime = System.currentTimeMillis();
            long executionTime = endTime - startTime;
            
            logger.info("方法 {} 執行時間: {} ms", methodName, executionTime);
            
            return result;
        } catch (Exception e) {
            long endTime = System.currentTimeMillis();
            long executionTime = endTime - startTime;
            
            logger.error("方法 {} 執行失敗，耗時: {} ms, 異常: {}", 
                        methodName, executionTime, e.getMessage());
            throw e;
        }
    }
    
    @Around("@annotation(cacheable)")
    public Object handleCaching(ProceedingJoinPoint joinPoint, Cacheable cacheable) throws Throwable {
        String cacheKey = generateCacheKey(joinPoint, cacheable);
        
        // 檢查快取
        Object cachedResult = cacheManager.get(cacheKey);
        if (cachedResult != null) {
            logger.debug("快取命中: {}", cacheKey);
            return cachedResult;
        }
        
        // 執行方法並快取結果
        Object result = joinPoint.proceed();
        cacheManager.put(cacheKey, result);
        logger.debug("結果已快取: {}", cacheKey);
        
        return result;
    }
}

@Aspect
@Component
public class PointcutExamples {
    
    // 1. 方法執行切點
    @Pointcut("execution(public * com.tutorial.service.*.*(..))")
    public void serviceLayer() {}
    
    @Pointcut("execution(* com.tutorial.repository.*Repository.*(..))")
    public void repositoryLayer() {}
    
    @Pointcut("execution(* com.tutorial.controller.*Controller.*(..))")
    public void controllerLayer() {}
    
    // 2. 參數匹配
    @Pointcut("execution(* com.tutorial.service.*.*(Long, ..))")
    public void methodsWithLongFirstParam() {}
    
    // 3. 返回類型匹配
    @Pointcut("execution(com.tutorial.model.User com.tutorial.service.*.*(..))")
    public void methodsReturningUser() {}
    
    // 4. 註解切點
    @Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
    public void transactionalMethods() {}
    
    @Pointcut("@within(org.springframework.stereotype.Service)")
    public void serviceAnnotatedClasses() {}
    
    // 5. 組合切點
    @Pointcut("serviceLayer() && transactionalMethods()")
    public void transactionalServiceMethods() {}
    
    @Pointcut("serviceLayer() || repositoryLayer()")
    public void dataAccessLayers() {}
    
    @Pointcut("serviceLayer() && !execution(* com.tutorial.service.*Service.get*(..))")
    public void nonGetterServiceMethods() {}
}

@Component
@Aspect
public class CommonPointcuts {
    
    // 所有公共方法
    @Pointcut("execution(public * *(..))")
    public void anyPublicMethod() {}
    
    // 特定包下的所有方法
    @Pointcut("within(com.tutorial.service..*)")
    public void inServicePackage() {}
    
    // 實現特定接口的類
    @Pointcut("this(com.tutorial.service.UserService)")
    public void userServiceProxy() {}
    
    // 目標物件實現特定接口
    @Pointcut("target(com.tutorial.service.UserService)")
    public void userServiceTarget() {}
    
    // Bean 名稱匹配
    @Pointcut("bean(userService)")
    public void userServiceBean() {}
    
    @Pointcut("bean(*Service)")
    public void anyServiceBean() {}
    
    // 自定義註解
    @Pointcut("@annotation(com.tutorial.annotation.Auditable)")
    public void auditableMethods() {}
    
    @Pointcut("@args(com.tutorial.annotation.Validated)")
    public void methodsWithValidatedArgs() {}
}

// 日誌註解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Loggable {
    String value() default "";
    boolean includeArgs() default true;
    boolean includeResult() default true;
}

// 快取註解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Cacheable {
    String value() default "";
    String key() default "";
    int timeout() default 300; // 秒
}

// 重試註解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Retryable {
    int maxAttempts() default 3;
    long delay() default 1000; // 毫秒
    Class<? extends Exception>[] retryFor() default {Exception.class};
}

@Aspect
@Component
public class CustomAnnotationAspect {
    
    @Around("@annotation(loggable)")
    public Object handleLogging(ProceedingJoinPoint joinPoint, Loggable loggable) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        String logMessage = loggable.value().isEmpty() ? methodName : loggable.value();
        
        if (loggable.includeArgs()) {
            logger.info("開始執行 {}, 參數: {}", logMessage, Arrays.toString(joinPoint.getArgs()));
        } else {
            logger.info("開始執行 {}", logMessage);
        }
        
        try {
            Object result = joinPoint.proceed();
            
            if (loggable.includeResult()) {
                logger.info("完成執行 {}, 結果: {}", logMessage, result);
            } else {
                logger.info("完成執行 {}", logMessage);
            }
            
            return result;
        } catch (Exception e) {
            logger.error("執行 {} 時發生錯誤: {}", logMessage, e.getMessage());
            throw e;
        }
    }
    
    @Around("@annotation(retryable)")
    public Object handleRetry(ProceedingJoinPoint joinPoint, Retryable retryable) throws Throwable {
        int maxAttempts = retryable.maxAttempts();
        long delay = retryable.delay();
        Class<? extends Exception>[] retryFor = retryable.retryFor();
        
        Exception lastException = null;
        
        for (int attempt = 1; attempt <= maxAttempts; attempt++) {
            try {
                return joinPoint.proceed();
            } catch (Exception e) {
                lastException = e;
                
                // 檢查是否是需要重試的異常類型
                boolean shouldRetry = Arrays.stream(retryFor)
                    .anyMatch(exceptionType -> exceptionType.isAssignableFrom(e.getClass()));
                    
                if (!shouldRetry || attempt == maxAttempts) {
                    throw e;
                }
                
                logger.warn("方法 {} 第 {} 次嘗試失敗，將在 {} ms 後重試: {}", 
                           joinPoint.getSignature().getName(), attempt, delay, e.getMessage());
                
                try {
                    Thread.sleep(delay);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("重試被中斷", ie);
                }
            }
        }
        
        throw lastException;
    }
}

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true) // 強制使用 CGLIB 代理
public class AopConfig {
    
    // AOP 相關的 Bean 配置
}

// 或在 Spring Boot 中自動啟用
@SpringBootApplication
// @EnableAspectJAutoProxy 自動啟用
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// JDK 動態代理 - 基於接口
public interface UserService {
    User findById(Long id);
    User save(User user);
}

@Service
public class UserServiceImpl implements UserService {
    @Override
    public User findById(Long id) {
        // 實現邏輯
    }
    
    @Override
    public User save(User user) {
        // 實現邏輯
    }
}

// CGLIB 代理 - 基於類別
@Service
public class OrderService { // 無接口
    
    public Order findById(Long id) {
        // 實現邏輯
    }
    
    // final 方法無法被代理
    public final void finalMethod() {
        // 此方法不會被 AOP 攔截
    }
}

// 完整的 AOP 應用範例
@Aspect
@Component
@Order(1) // 設定切面執行順序
public class BusinessAspect {
    
    private final MeterRegistry meterRegistry;
    private final AuditService auditService;
    
    public BusinessAspect(MeterRegistry meterRegistry, AuditService auditService) {
        this.meterRegistry = meterRegistry;
        this.auditService = auditService;
    }
    
    // 業務方法性能監控
    @Around("execution(* com.tutorial.service.*Service.*(..))")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        Timer.Sample sample = Timer.start(meterRegistry);
        String methodName = joinPoint.getSignature().toShortString();
        
        try {
            Object result = joinPoint.proceed();
            sample.stop(Timer.builder("method.execution")
                .tag("method", methodName)
                .tag("status", "success")
                .register(meterRegistry));
            return result;
        } catch (Exception e) {
            sample.stop(Timer.builder("method.execution")
                .tag("method", methodName)
                .tag("status", "error")
                .register(meterRegistry));
            throw e;
        }
    }
    
    // 敏感操作審計
    @AfterReturning("@annotation(auditable)")
    public void auditSensitiveOperation(JoinPoint joinPoint, Auditable auditable) {
        String operation = auditable.operation();
        String user = SecurityContextHolder.getContext().getAuthentication().getName();
        Object[] args = joinPoint.getArgs();
        
        auditService.logOperation(operation, user, args);
    }
}

// 使用範例
@Service
@Transactional
public class UserService {
    
    @Loggable("查詢用戶")
    @Retryable(maxAttempts = 3, retryFor = {DataAccessException.class})
    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("用戶不存在: " + id));
    }
    
    @Auditable(operation = "創建用戶")
    @Cacheable(key = "user:#{result.id}", timeout = 600)
    public User createUser(CreateUserRequest request) {
        User user = new User(request);
        return userRepository.save(user);
    }
}

// Resource 接口的使用
@Service
public class ConfigurationService {
    
    @Autowired
    private ResourceLoader resourceLoader;
    
    public Properties loadConfiguration(String location) throws IOException {
        Resource resource = resourceLoader.getResource(location);
        Properties properties = new Properties();
        
        try (InputStream inputStream = resource.getInputStream()) {
            properties.load(inputStream);
        }
        
        return properties;
    }
    
    public void demonstrateResourceTypes() throws IOException {
        // 1. Classpath 資源
        Resource classpathResource = resourceLoader.getResource("classpath:config.properties");
        
        // 2. 文件系統資源
        Resource fileResource = resourceLoader.getResource("file:/path/to/config.properties");
        
        // 3. URL 資源
        Resource urlResource = resourceLoader.getResource("http://example.com/config.properties");
        
        // 4. 相對路徑資源
        Resource relativeResource = resourceLoader.getResource("config/app.properties");
        
        // 檢查資源是否存在
        if (classpathResource.exists()) {
            System.out.println("資源存在: " + classpathResource.getDescription());
            System.out.println("檔案大小: " + classpathResource.contentLength());
            System.out.println("最後修改時間: " + new Date(classpathResource.lastModified()));
        }
    }
}

// 自定義類型轉換器
@Component
public class StringToDateConverter implements Converter<String, Date> {
    
    private final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    
    @Override
    public Date convert(String source) {
        try {
            return dateFormat.parse(source);
        } catch (ParseException e) {
            throw new IllegalArgumentException("無效的日期格式: " + source, e);
        }
    }
}

// 配置轉換服務
@Configuration
public class ConversionConfig {
    
    @Bean
    public ConversionService conversionService() {
        DefaultConversionService conversionService = new DefaultConversionService();
        conversionService.addConverter(new StringToDateConverter());
        return conversionService;
    }
}

// 使用轉換服務
@Service
public class UserService {
    
    @Autowired
    private ConversionService conversionService;
    
    public User createUser(String birthDateString) {
        Date birthDate = conversionService.convert(birthDateString, Date.class);
        return new User(birthDate);
    }
}

// ApplicationContext 的進階使用
@Component
public class ApplicationContextService implements ApplicationContextAware {
    
    private ApplicationContext applicationContext;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    
    public void demonstrateContextFeatures() {
        // 1. Bean 管理
        UserService userService = applicationContext.getBean(UserService.class);
        boolean containsBean = applicationContext.containsBean("userService");
        String[] beanNames = applicationContext.getBeanNamesForType(UserService.class);
        
        // 2. 環境和 Profile
        Environment environment = applicationContext.getEnvironment();
        String[] activeProfiles = environment.getActiveProfiles();
        String property = environment.getProperty("app.name", "default-app");
        
        // 3. 國際化
        Locale locale = Locale.getDefault();
        String message = applicationContext.getMessage("welcome.message", 
            new Object[]{"Spring"}, locale);
        
        // 4. 事件發布
        applicationContext.publishEvent(new CustomApplicationEvent(this, "測試事件"));
        
        // 5. 資源載入
        Resource resource = applicationContext.getResource("classpath:config.xml");
    }
}

// 國際化配置
@Configuration
public class InternationalizationConfig {
    
    @Bean
    public MessageSource messageSource() {
        ReloadableResourceBundleMessageSource messageSource = 
            new ReloadableResourceBundleMessageSource();
        messageSource.setBasename("classpath:messages/messages");
        messageSource.setDefaultEncoding("UTF-8");
        messageSource.setCacheSeconds(3600); // 快取 1 小時
        return messageSource;
    }
    
    @Bean
    public LocaleResolver localeResolver() {
        SessionLocaleResolver localeResolver = new SessionLocaleResolver();
        localeResolver.setDefaultLocale(Locale.TRADITIONAL_CHINESE);
        return localeResolver;
    }
}

// 使用國際化
@Service
public class MessageService {
    
    @Autowired
    private MessageSource messageSource;
    
    public String getMessage(String code, Object[] args, Locale locale) {
        return messageSource.getMessage(code, args, locale);
    }
    
    public String getLocalizedWelcomeMessage(String username, Locale locale) {
        return messageSource.getMessage("welcome.user", 
            new Object[]{username}, "歡迎 {0}", locale);
    }
}

// messages_zh_TW.properties
// welcome.user=歡迎 {0}！
// error.user.notfound=找不到用戶 {0}
// success.user.created=成功創建用戶 {0}

// messages_en.properties  
// welcome.user=Welcome {0}!
// error.user.notfound=User {0} not found
// success.user.created=User {0} created successfully

// BeanWrapper 的使用
@Service
public class BeanManipulationService {
    
    public void demonstrateBeanWrapper() {
        User user = new User();
        BeanWrapper beanWrapper = new BeanWrapperImpl(user);
        
        // 設定屬性值
        beanWrapper.setPropertyValue("name", "張三");
        beanWrapper.setPropertyValue("age", 30);
        beanWrapper.setPropertyValue("email", "zhangsan@example.com");
        
        // 批量設定屬性
        Map<String, Object> properties = new HashMap<>();
        properties.put("phone", "123-456-7890");
        properties.put("address.city", "台北");
        properties.put("address.zipCode", "100");
        beanWrapper.setPropertyValues(properties);
        
        // 讀取屬性值
        String name = (String) beanWrapper.getPropertyValue("name");
        Integer age = (Integer) beanWrapper.getPropertyValue("age");
        
        // 檢查屬性
        boolean hasName = beanWrapper.isReadableProperty("name");
        boolean canWriteAge = beanWrapper.isWritableProperty("age");
        
        System.out.println("用戶: " + name + ", 年齡: " + age);
    }
    
    public void copyProperties(Object source, Object target) {
        BeanWrapper sourceWrapper = new BeanWrapperImpl(source);
        BeanWrapper targetWrapper = new BeanWrapperImpl(target);
        
        PropertyDescriptor[] propertyDescriptors = sourceWrapper.getPropertyDescriptors();
        
        for (PropertyDescriptor pd : propertyDescriptors) {
            String propertyName = pd.getName();
            if (sourceWrapper.isReadableProperty(propertyName) && 
                targetWrapper.isWritableProperty(propertyName)) {
                
                Object value = sourceWrapper.getPropertyValue(propertyName);
                targetWrapper.setPropertyValue(propertyName, value);
            }
        }
    }
}

// 程式化創建 Bean 定義
@Configuration
public class DynamicBeanConfig {
    
    @Bean
    public BeanDefinitionRegistryPostProcessor dynamicBeanRegistrar() {
        return new BeanDefinitionRegistryPostProcessor() {
            
            @Override
            public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 
                    throws BeansException {
                // 動態註冊 Bean
                registerDataSourceBeans(registry);
            }
            
            @Override
            public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
                    throws BeansException {
                // Bean 工廠後處理
            }
            
            private void registerDataSourceBeans(BeanDefinitionRegistry registry) {
                // 讀取配置檔案中的資料源配置
                List<DataSourceConfig> configs = loadDataSourceConfigs();
                
                for (DataSourceConfig config : configs) {
                    BeanDefinitionBuilder builder = BeanDefinitionBuilder
                        .genericBeanDefinition(HikariDataSource.class);
                    
                    builder.addPropertyValue("jdbcUrl", config.getUrl());
                    builder.addPropertyValue("username", config.getUsername());
                    builder.addPropertyValue("password", config.getPassword());
                    builder.addPropertyValue("maximumPoolSize", config.getMaxPoolSize());
                    
                    registry.registerBeanDefinition(config.getName() + "DataSource", 
                        builder.getBeanDefinition());
                }
            }
        };
    }
}

// SpEL 表達式範例
@Component
public class SpELDemonstration {
    
    // 字面值
    @Value("#{100}")
    private int literalNumber;
    
    @Value("#{'Hello World'}")
    private String literalString;
    
    @Value("#{true}")
    private boolean literalBoolean;
    
    // 屬性引用
    @Value("#{systemProperties['user.name']}")
    private String userName;
    
    @Value("#{environment['spring.application.name']}")
    private String appName;
    
    // Bean 引用
    @Value("#{userService.getUserCount()}")
    private int userCount;
    
    @Value("#{@userService.findActiveUsers().size()}")
    private int activeUserCount;
    
    // 運算符
    @Value("#{10 + 5}")
    private int addition;
    
    @Value("#{userService.getUserCount() > 100}")
    private boolean hasLargeUserBase;
    
    @Value("#{userService.getUserCount() > 100 ? 'Large' : 'Small'}")
    private String userBaseSize;
    
    // 正則表達式
    @Value("#{'123-456-7890' matches '\\d{3}-\\d{3}-\\d{4}'}")
    private boolean isValidPhoneNumber;
    
    // 集合操作
    @Value("#{userService.getAllUsers().?[age > 18]}")
    private List<User> adultUsers;
    
    @Value("#{userService.getAllUsers().![name]}")
    private List<String> userNames;
    
    @Value("#{userService.getAllUsers().^[age > 18]}")
    private User firstAdultUser;
    
    @Value("#{userService.getAllUsers().$[age > 18]}")
    private User lastAdultUser;
}

// 條件式配置
@Configuration
@ConditionalOnExpression("#{environment['app.features.advanced'] == 'true'}")
public class AdvancedFeatureConfig {
    
    @Bean
    @ConditionalOnExpression("#{T(java.lang.Runtime).getRuntime().availableProcessors() > 4}")
    public TaskExecutor highPerformanceTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(8);
        executor.setMaxPoolSize(16);
        return executor;
    }
}

// 動態屬性注入
@Component
public class DynamicConfiguration {
    
    @Value("#{environment['server.port'] ?: 8080}")
    private int serverPort;
    
    @Value("#{environment['app.timeout'] ?: 30000}")
    private long timeout;
    
    @Value("#{environment['app.features'].split(',')}")
    private List<String> enabledFeatures;
    
    @Value("#{T(java.time.LocalDateTime).now()}")
    private LocalDateTime startupTime;
    
    @Value("#{T(java.util.UUID).randomUUID().toString()}")
    private String instanceId;
}

// 方法安全性中的 SpEL
@Service
public class DocumentService {
    
    @PreAuthorize("hasRole('ADMIN') or #userId == authentication.principal.id")
    public Document getDocument(Long documentId, Long userId) {
        return documentRepository.findById(documentId);
    }
    
    @PreAuthorize("@documentSecurityService.hasPermission(authentication.principal, #doc, 'READ')")
    public void viewDocument(Document doc) {
        // 查看文檔
    }
    
    @PostAuthorize("returnObject.owner == authentication.principal.username")
    public Document createDocument(DocumentRequest request) {
        Document doc = new Document(request);
        doc.setOwner(getCurrentUser().getUsername());
        return documentRepository.save(doc);
    }
}

// Environment 的進階使用
@Service
public class EnvironmentService {
    
    @Autowired
    private Environment environment;
    
    public void demonstrateEnvironment() {
        // 1. Profile 管理
        String[] activeProfiles = environment.getActiveProfiles();
        String[] defaultProfiles = environment.getDefaultProfiles();
        boolean isDevMode = environment.acceptsProfiles(Profiles.of("development"));
        
        // 2. 屬性獲取
        String appName = environment.getProperty("app.name");
        String appVersion = environment.getProperty("app.version", "1.0.0");
        Integer maxConnections = environment.getProperty("app.max-connections", Integer.class);
        
        // 3. 必需屬性
        String requiredProperty = environment.getRequiredProperty("database.url");
        
        // 4. 屬性佔位符解析
        String template = "應用程式 ${app.name} 版本 ${app.version} 正在運行";
        String resolved = environment.resolvePlaceholders(template);
        
        // 5. 檢查屬性是否存在
        boolean hasProperty = environment.containsProperty("spring.datasource.url");
        
        System.out.println("活動 Profile: " + Arrays.toString(activeProfiles));
        System.out.println("應用程式資訊: " + resolved);
    }
}

// 自定義 PropertySource
@Configuration
public class CustomPropertySourceConfig {
    
    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        PropertySourcesPlaceholderConfigurer configurer = 
            new PropertySourcesPlaceholderConfigurer();
        
        // 添加自定義屬性源
        YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
        yaml.setResources(new ClassPathResource("custom-config.yml"));
        configurer.setProperties(yaml.getObject());
        
        return configurer;
    }
    
    @EventListener
    public void handleApplicationReady(ApplicationReadyEvent event) {
        ConfigurableEnvironment environment = event.getApplicationContext().getEnvironment();
        
        // 程式化添加屬性源
        Map<String, Object> customProperties = new HashMap<>();
        customProperties.put("custom.startup.time", System.currentTimeMillis());
        customProperties.put("custom.instance.id", UUID.randomUUID().toString());
        
        MapPropertySource customPropertySource = new MapPropertySource(
            "customProperties", customProperties);
        environment.getPropertySources().addFirst(customPropertySource);
    }
}

// 完整的核心模組應用範例
@Configuration
@EnableConfigurationProperties(AppProperties.class)
public class CoreModuleDemo {
    
    @Autowired
    private Environment environment;
    
    @Bean
    @ConditionalOnExpression("#{environment['app.features.cache'] == 'true'}")
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        
        // 使用 SpEL 動態配置快取
        String cacheNames = environment.getProperty("app.cache.names", "users,orders");
        List<Cache> caches = Arrays.stream(cacheNames.split(","))
            .map(name -> new ConcurrentMapCache(name.trim()))
            .collect(Collectors.toList());
            
        cacheManager.setCaches(caches);
        return cacheManager;
    }
    
    @Bean
    public MessageSource messageSource() {
        ReloadableResourceBundleMessageSource messageSource = 
            new ReloadableResourceBundleMessageSource();
        
        String basename = environment.getProperty("app.messages.basename", 
            "classpath:messages/messages");
        messageSource.setBasename(basename);
        messageSource.setDefaultEncoding("UTF-8");
        
        return messageSource;
    }
    
    @Bean
    @Profile("!test")
    public ResourceLoader customResourceLoader() {
        return new DefaultResourceLoader() {
            @Override
            public Resource getResource(String location) {
                // 自定義資源載入邏輯
                if (location.startsWith("encrypted:")) {
                    return new EncryptedResource(location.substring(10));
                }
                return super.getResource(location);
            }
        };
    }
}

@ConfigurationProperties(prefix = "app")
@Data
public class AppProperties {
    private String name = "Spring Application";
    private String version = "1.0.0";
    private Features features = new Features();
    private Cache cache = new Cache();
    
    @Data
    public static class Features {
        private boolean cache = false;
        private boolean advanced = false;
    }
    
    @Data
    public static class Cache {
        private String names = "default";
        private int ttl = 300;
    }
}

// Web 應用程式初始化器
public class WebAppInitializer implements WebApplicationInitializer {
    
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        // 創建 Root ApplicationContext
        AnnotationConfigWebApplicationContext rootContext = 
            new AnnotationConfigWebApplicationContext();
        rootContext.register(RootConfig.class);
        
        // 註冊 ContextLoaderListener
        servletContext.addListener(new ContextLoaderListener(rootContext));
        
        // 創建 Web ApplicationContext
        AnnotationConfigWebApplicationContext webContext = 
            new AnnotationConfigWebApplicationContext();
        webContext.register(WebConfig.class);
        
        // 註冊 DispatcherServlet
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet(
            "dispatcher", new DispatcherServlet(webContext));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
        
        // 註冊編碼過濾器
        FilterRegistration.Dynamic encodingFilter = servletContext.addFilter(
            "encodingFilter", new CharacterEncodingFilter());
        encodingFilter.addMappingForUrlPatterns(null, false, "/*");
        encodingFilter.setInitParameter("encoding", "UTF-8");
        encodingFilter.setInitParameter("forceEncoding", "true");
    }
}

// 根配置類
@Configuration
@ComponentScan(basePackages = "com.tutorial", 
               excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, 
                                                     value = EnableWebMvc.class))
public class RootConfig {
    // 非 Web 層的配置
}

// Web 配置類
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.tutorial.web")
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/views/", ".jsp");
    }
    
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
                .addResourceLocations("/static/")
                .setCacheControl(CacheControl.maxAge(Duration.ofDays(365)));
    }
    
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

@SpringBootApplication
public class WebApplication {
    public static void main(String[] args) {
        SpringApplication.run(WebApplication.class, args);
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOrigins("http://localhost:3000")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*")
                .allowCredentials(true);
    }
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoggingInterceptor())
                .addPathPatterns("/api/**");
        
        registry.addInterceptor(new AuthenticationInterceptor())
                .addPathPatterns("/api/admin/**");
    }
    
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(new MappingJackson2HttpMessageConverter());
        converters.add(new StringHttpMessageConverter(StandardCharsets.UTF_8));
    }
}

@Controller
@RequestMapping("/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    // 顯示用戶列表
    @GetMapping
    public String listUsers(Model model, 
                          @RequestParam(defaultValue = "0") int page,
                          @RequestParam(defaultValue = "10") int size) {
        Page<User> userPage = userService.findUsers(PageRequest.of(page, size));
        model.addAttribute("users", userPage.getContent());
        model.addAttribute("currentPage", page);
        model.addAttribute("totalPages", userPage.getTotalPages());
        return "users/list";
    }
    
    // 顯示用戶詳情
    @GetMapping("/{id}")
    public String showUser(@PathVariable Long id, Model model) {
        User user = userService.findById(id);
        if (user == null) {
            throw new UserNotFoundException("用戶不存在: " + id);
        }
        model.addAttribute("user", user);
        return "users/detail";
    }
    
    // 顯示創建用戶表單
    @GetMapping("/new")
    public String newUserForm(Model model) {
        model.addAttribute("user", new User());
        return "users/form";
    }
    
    // 處理用戶創建
    @PostMapping
    public String createUser(@Valid @ModelAttribute User user, 
                           BindingResult bindingResult,
                           RedirectAttributes redirectAttributes) {
        if (bindingResult.hasErrors()) {
            return "users/form";
        }
        
        User savedUser = userService.save(user);
        redirectAttributes.addFlashAttribute("message", 
            "用戶創建成功: " + savedUser.getName());
        return "redirect:/users/" + savedUser.getId();
    }
    
    // 顯示編輯用戶表單
    @GetMapping("/{id}/edit")
    public String editUserForm(@PathVariable Long id, Model model) {
        User user = userService.findById(id);
        model.addAttribute("user", user);
        return "users/form";
    }
    
    // 處理用戶更新
    @PutMapping("/{id}")
    public String updateUser(@PathVariable Long id,
                           @Valid @ModelAttribute User user,
                           BindingResult bindingResult,
                           RedirectAttributes redirectAttributes) {
        if (bindingResult.hasErrors()) {
            return "users/form";
        }
        
        user.setId(id);
        userService.update(user);
        redirectAttributes.addFlashAttribute("message", "用戶更新成功");
        return "redirect:/users/" + id;
    }
    
    // 刪除用戶
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable Long id, 
                           RedirectAttributes redirectAttributes) {
        userService.delete(id);
        redirectAttributes.addFlashAttribute("message", "用戶刪除成功");
        return "redirect:/users";
    }
}

@RestController
@RequestMapping("/api/users")
@Validated
public class UserRestController {
    
    private final UserService userService;
    
    public UserRestController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping
    public ResponseEntity<PagedResponse<UserDTO>> getUsers(
            @RequestParam(defaultValue = "0") @Min(0) int page,
            @RequestParam(defaultValue = "10") @Min(1) @Max(100) int size,
            @RequestParam(required = false) String search) {
        
        Pageable pageable = PageRequest.of(page, size);
        Page<User> userPage = userService.findUsers(search, pageable);
        
        List<UserDTO> userDTOs = userPage.getContent().stream()
            .map(UserDTO::from)
            .collect(Collectors.toList());
            
        PagedResponse<UserDTO> response = new PagedResponse<>(
            userDTOs, 
            userPage.getNumber(), 
            userPage.getSize(),
            userPage.getTotalElements(),
            userPage.getTotalPages()
        );
        
        return ResponseEntity.ok(response);
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<UserDTO> getUser(@PathVariable @Positive Long id) {
        User user = userService.findById(id);
        return ResponseEntity.ok(UserDTO.from(user));
    }
    
    @PostMapping
    public ResponseEntity<UserDTO> createUser(@Valid @RequestBody CreateUserRequest request) {
        User user = userService.create(request);
        UserDTO userDTO = UserDTO.from(user);
        
        URI location = ServletUriComponentsBuilder
            .fromCurrentRequest()
            .path("/{id}")
            .buildAndExpand(user.getId())
            .toUri();
            
        return ResponseEntity.created(location).body(userDTO);
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<UserDTO> updateUser(@PathVariable @Positive Long id,
                                            @Valid @RequestBody UpdateUserRequest request) {
        User user = userService.update(id, request);
        return ResponseEntity.ok(UserDTO.from(user));
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable @Positive Long id) {
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
    
    @PostMapping("/{id}/avatar")
    public ResponseEntity<UserDTO> uploadAvatar(@PathVariable @Positive Long id,
                                              @RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            throw new BadRequestException("檔案不能為空");
        }
        
        // 檢查檔案類型
        String contentType = file.getContentType();
        if (!Arrays.asList("image/jpeg", "image/png", "image/gif").contains(contentType)) {
            throw new BadRequestException("不支援的檔案類型");
        }
        
        // 檢查檔案大小 (5MB)
        if (file.getSize() > 5 * 1024 * 1024) {
            throw new BadRequestException("檔案大小不能超過 5MB");
        }
        
        User user = userService.updateAvatar(id, file);
        return ResponseEntity.ok(UserDTO.from(user));
    }
}

@RestController
@RequestMapping("/api/demo")
public class ParameterBindingController {
    
    // 路徑變數
    @GetMapping("/users/{userId}/orders/{orderId}")
    public ResponseEntity<String> getOrder(@PathVariable Long userId,
                                         @PathVariable("orderId") Long id) {
        return ResponseEntity.ok("User: " + userId + ", Order: " + id);
    }
    
    // 請求參數
    @GetMapping("/search")
    public ResponseEntity<String> search(
            @RequestParam String keyword,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size,
            @RequestParam(required = false) String category) {
        return ResponseEntity.ok("搜尋: " + keyword);
    }
    
    // 請求頭
    @GetMapping("/headers")
    public ResponseEntity<String> getHeaders(
            @RequestHeader("User-Agent") String userAgent,
            @RequestHeader(value = "Accept-Language", defaultValue = "zh-TW") String language,
            @RequestHeader Map<String, String> allHeaders) {
        return ResponseEntity.ok("User-Agent: " + userAgent);
    }
    
    // Cookie
    @GetMapping("/cookies")
    public ResponseEntity<String> getCookies(
            @CookieValue(value = "session", defaultValue = "none") String sessionId,
            HttpServletRequest request) {
        return ResponseEntity.ok("Session: " + sessionId);
    }
    
    // 請求體
    @PostMapping("/data")
    public ResponseEntity<String> postData(@RequestBody Map<String, Object> data,
                                         @RequestHeader("Content-Type") String contentType) {
        return ResponseEntity.ok("接收到資料: " + data.size() + " 項");
    }
    
    // 表單資料
    @PostMapping("/form")
    public ResponseEntity<String> handleForm(
            @RequestParam String name,
            @RequestParam String email,
            @RequestParam MultipartFile file) {
        return ResponseEntity.ok("表單提交成功: " + name);
    }
    
    // 模型屬性
    @PostMapping("/user")
    public ResponseEntity<String> createUser(@ModelAttribute User user,
                                           BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            return ResponseEntity.badRequest().body("驗證失敗");
        }
        return ResponseEntity.ok("用戶創建: " + user.getName());
    }
    
    // 會話屬性
    @PostMapping("/session")
    public ResponseEntity<String> sessionData(@SessionAttribute(required = false) User currentUser,
                                            HttpSession session) {
        if (currentUser == null) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("請先登入");
        }
        return ResponseEntity.ok("當前用戶: " + currentUser.getName());
    }
}

// 自定義註解
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CurrentUser {
}

// 自定義參數解析器
@Component
public class CurrentUserArgumentResolver implements HandlerMethodArgumentResolver {
    
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(CurrentUser.class) &&
               parameter.getParameterType().equals(User.class);
    }
    
    @Override
    public Object resolveArgument(MethodParameter parameter, 
                                ModelAndViewContainer mavContainer,
                                NativeWebRequest webRequest, 
                                WebDataBinderFactory binderFactory) throws Exception {
        
        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
        String authorization = request.getHeader("Authorization");
        
        if (authorization != null && authorization.startsWith("Bearer ")) {
            String token = authorization.substring(7);
            return userService.getUserFromToken(token);
        }
        
        throw new UnauthorizedException("無效的認證令牌");
    }
}

// 註冊解析器
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    
    @Autowired
    private CurrentUserArgumentResolver currentUserArgumentResolver;
    
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(currentUserArgumentResolver);
    }
}

// 使用自定義解析器
@RestController
@RequestMapping("/api/profile")
public class ProfileController {
    
    @GetMapping
    public ResponseEntity<UserDTO> getProfile(@CurrentUser User currentUser) {
        return ResponseEntity.ok(UserDTO.from(currentUser));
    }
    
    @PutMapping
    public ResponseEntity<UserDTO> updateProfile(@CurrentUser User currentUser,
                                                @Valid @RequestBody UpdateProfileRequest request) {
        User updatedUser = userService.updateProfile(currentUser.getId(), request);
        return ResponseEntity.ok(UserDTO.from(updatedUser));
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    // 處理驗證異常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(
            MethodArgumentNotValidException e) {
        
        Map<String, String> errors = new HashMap<>();
        e.getBindingResult().getFieldErrors().forEach(error -> 
            errors.put(error.getField(), error.getDefaultMessage()));
            
        ErrorResponse errorResponse = ErrorResponse.builder()
            .timestamp(LocalDateTime.now())
            .status(HttpStatus.BAD_REQUEST.value())
            .error("Validation Failed")
            .message("請求參數驗證失敗")
            .path(getCurrentRequest().getRequestURI())
            .validationErrors(errors)
            .build();
            
        return ResponseEntity.badRequest().body(errorResponse);
    }
    
    // 處理約束違反異常
    @ExceptionHandler(ConstraintViolationException.class)
    public ResponseEntity<ErrorResponse> handleConstraintViolationException(
            ConstraintViolationException e) {
        
        Map<String, String> errors = new HashMap<>();
        e.getConstraintViolations().forEach(violation -> {
            String propertyPath = violation.getPropertyPath().toString();
            String message = violation.getMessage();
            errors.put(propertyPath, message);
        });
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .timestamp(LocalDateTime.now())
            .status(HttpStatus.BAD_REQUEST.value())
            .error("Constraint Violation")
            .message("參數約束違反")
            .validationErrors(errors)
            .build();
            
        return ResponseEntity.badRequest().body(errorResponse);
    }
    
    // 處理業務異常
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException e) {
        logger.warn("業務異常: {}", e.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .timestamp(LocalDateTime.now())
            .status(e.getStatus().value())
            .error(e.getStatus().getReasonPhrase())
            .message(e.getMessage())
            .build();
            
        return ResponseEntity.status(e.getStatus()).body(errorResponse);
    }
    
    // 處理資源不存在異常
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleResourceNotFoundException(
            ResourceNotFoundException e) {
        logger.warn("資源不存在: {}", e.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .timestamp(LocalDateTime.now())
            .status(HttpStatus.NOT_FOUND.value())
            .error("Not Found")
            .message(e.getMessage())
            .build();
            
        return ResponseEntity.notFound().build();
    }
    
    // 處理權限不足異常
    @ExceptionHandler(AccessDeniedException.class)
    public ResponseEntity<ErrorResponse> handleAccessDeniedException(
            AccessDeniedException e) {
        logger.warn("權限不足: {}", e.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .timestamp(LocalDateTime.now())
            .status(HttpStatus.FORBIDDEN.value())
            .error("Forbidden")
            .message("權限不足")
            .build();
            
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body(errorResponse);
    }
    
    // 處理通用異常
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception e) {
        logger.error("未處理的異常", e);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .timestamp(LocalDateTime.now())
            .status(HttpStatus.INTERNAL_SERVER_ERROR.value())
            .error("Internal Server Error")
            .message("系統內部錯誤")
            .build();
            
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
    
    private HttpServletRequest getCurrentRequest() {
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        return ((ServletRequestAttributes) requestAttributes).getRequest();
    }
}

// 錯誤響應 DTO
@Data
@Builder
public class ErrorResponse {
    private LocalDateTime timestamp;
    private int status;
    private String error;
    private String message;
    private String path;
    private Map<String, String> validationErrors;
}

// 日誌攔截器
public class LoggingInterceptor implements HandlerInterceptor {
    
    private static final Logger logger = LoggerFactory.getLogger(LoggingInterceptor.class);
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        String requestURI = request.getRequestURI();
        String method = request.getMethod();
        
        logger.info("請求開始 - {} {}", method, requestURI);
        
        // 記錄請求開始時間
        request.setAttribute("startTime", System.currentTimeMillis());
        
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, 
                         HttpServletResponse response,
                         Object handler, 
                         ModelAndView modelAndView) throws Exception {
        // Controller 處理完成後執行
        logger.debug("Controller 處理完成");
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, 
                              HttpServletResponse response,
                              Object handler, 
                              Exception ex) throws Exception {
        Long startTime = (Long) request.getAttribute("startTime");
        long endTime = System.currentTimeMillis();
        long duration = endTime - startTime;
        
        String requestURI = request.getRequestURI();
        String method = request.getMethod();
        int status = response.getStatus();
        
        logger.info("請求結束 - {} {} - 狀態: {} - 耗時: {}ms", 
                   method, requestURI, status, duration);
        
        if (ex != null) {
            logger.error("請求處理異常", ex);
        }
    }
}

// 認證攔截器
public class AuthenticationInterceptor implements HandlerInterceptor {
    
    private final AuthService authService;
    
    public AuthenticationInterceptor(AuthService authService) {
        this.authService = authService;
    }
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        
        // 檢查是否需要認證
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            
            // 檢查方法或類別是否有 @NoAuth 註解
            if (handlerMethod.hasMethodAnnotation(NoAuth.class) ||
                handlerMethod.getBeanType().isAnnotationPresent(NoAuth.class)) {
                return true;
            }
        }
        
        String authorization = request.getHeader("Authorization");
        if (authorization == null || !authorization.startsWith("Bearer ")) {
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write("{\"error\":\"未提供認證令牌\"}");
            return false;
        }
        
        String token = authorization.substring(7);
        try {
            User user = authService.validateToken(token);
            request.setAttribute("currentUser", user);
            return true;
        } catch (Exception e) {
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write("{\"error\":\"無效的認證令牌\"}");
            return false;
        }
    }
}

// 完整的 REST API 範例
@RestController
@RequestMapping("/api/v1/orders")
@Validated
public class OrderController {
    
    private final OrderService orderService;
    private final OrderMapper orderMapper;
    
    public OrderController(OrderService orderService, OrderMapper orderMapper) {
        this.orderService = orderService;
        this.orderMapper = orderMapper;
    }
    
    @GetMapping
    @PreAuthorize("hasRole('USER')")
    public ResponseEntity<PagedResponse<OrderDTO>> getOrders(
            @CurrentUser User currentUser,
            @RequestParam(defaultValue = "0") @Min(0) int page,
            @RequestParam(defaultValue = "20") @Min(1) @Max(100) int size,
            @RequestParam(required = false) OrderStatus status) {
        
        Pageable pageable = PageRequest.of(page, size, Sort.by("createdAt").descending());
        Page<Order> orderPage = orderService.findUserOrders(currentUser.getId(), status, pageable);
        
        List<OrderDTO> orderDTOs = orderPage.getContent().stream()
            .map(orderMapper::toDTO)
            .collect(Collectors.toList());
            
        PagedResponse<OrderDTO> response = new PagedResponse<>(
            orderDTOs,
            orderPage.getNumber(),
            orderPage.getSize(),
            orderPage.getTotalElements(),
            orderPage.getTotalPages()
        );
        
        return ResponseEntity.ok(response);
    }
    
    @PostMapping
    @PreAuthorize("hasRole('USER')")
    public ResponseEntity<OrderDTO> createOrder(
            @CurrentUser User currentUser,
            @Valid @RequestBody CreateOrderRequest request) {
        
        Order order = orderService.createOrder(currentUser.getId(), request);
        OrderDTO orderDTO = orderMapper.toDTO(order);
        
        URI location = ServletUriComponentsBuilder
            .fromCurrentRequest()
            .path("/{id}")
            .buildAndExpand(order.getId())
            .toUri();
            
        return ResponseEntity.created(location).body(orderDTO);
    }
    
    @PutMapping("/{orderId}/cancel")
    @PreAuthorize("hasRole('USER')")
    public ResponseEntity<OrderDTO> cancelOrder(
            @CurrentUser User currentUser,
            @PathVariable @Positive Long orderId) {
        
        Order order = orderService.cancelOrder(currentUser.getId(), orderId);
        return ResponseEntity.ok(orderMapper.toDTO(order));
    }
}

// 資料源配置
@Configuration
public class DatabaseConfig {
    
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSourceProperties primaryDataSourceProperties() {
        return new DataSourceProperties();
    }
    
    @Bean
    @Primary
    public DataSource primaryDataSource() {
        return primaryDataSourceProperties()
            .initializeDataSourceBuilder()
            .type(HikariDataSource.class)
            .build();
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(@Qualifier("primaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    
    @Bean
    public NamedParameterJdbcTemplate namedParameterJdbcTemplate(
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return new NamedParameterJdbcTemplate(dataSource);
    }
}

// 基本的 JDBC Repository
@Repository
public class UserJdbcRepository {
    
    private final JdbcTemplate jdbcTemplate;
    private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;
    
    public UserJdbcRepository(JdbcTemplate jdbcTemplate,
                             NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
    }
    
    // 查詢單個物件
    public User findById(Long id) {
        String sql = "SELECT id, name, email, created_at FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(sql, new UserRowMapper(), id);
    }
    
    // 查詢列表
    public List<User> findAll() {
        String sql = "SELECT id, name, email, created_at FROM users ORDER BY name";
        return jdbcTemplate.query(sql, new UserRowMapper());
    }
    
    // 條件查詢
    public List<User> findByEmail(String email) {
        String sql = "SELECT id, name, email, created_at FROM users WHERE email LIKE ?";
        return jdbcTemplate.query(sql, new UserRowMapper(), "%" + email + "%");
    }
    
    // 統計查詢
    public long count() {
        String sql = "SELECT COUNT(*) FROM users";
        return jdbcTemplate.queryForObject(sql, Long.class);
    }
    
    // 插入資料
    public User save(User user) {
        if (user.getId() == null) {
            return insert(user);
        } else {
            return update(user);
        }
    }
    
    private User insert(User user) {
        String sql = "INSERT INTO users (name, email, created_at) VALUES (?, ?, ?)";
        
        KeyHolder keyHolder = new GeneratedKeyHolder();
        jdbcTemplate.update(connection -> {
            PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            ps.setString(1, user.getName());
            ps.setString(2, user.getEmail());
            ps.setTimestamp(3, Timestamp.valueOf(LocalDateTime.now()));
            return ps;
        }, keyHolder);
        
        user.setId(keyHolder.getKey().longValue());
        return user;
    }
    
    private User update(User user) {
        String sql = "UPDATE users SET name = ?, email = ? WHERE id = ?";
        int rowsAffected = jdbcTemplate.update(sql, user.getName(), user.getEmail(), user.getId());
        
        if (rowsAffected == 0) {
            throw new RuntimeException("用戶不存在: " + user.getId());
        }
        
        return user;
    }
    
    // 刪除資料
    public void deleteById(Long id) {
        String sql = "DELETE FROM users WHERE id = ?";
        int rowsAffected = jdbcTemplate.update(sql, id);
        
        if (rowsAffected == 0) {
            throw new RuntimeException("用戶不存在: " + id);
        }
    }
    
    // 批次操作
    public void batchInsert(List<User> users) {
        String sql = "INSERT INTO users (name, email, created_at) VALUES (?, ?, ?)";
        
        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps, int i) throws SQLException {
                User user = users.get(i);
                ps.setString(1, user.getName());
                ps.setString(2, user.getEmail());
                ps.setTimestamp(3, Timestamp.valueOf(LocalDateTime.now()));
            }
            
            @Override
            public int getBatchSize() {
                return users.size();
            }
        });
    }
}

// RowMapper 實現
public class UserRowMapper implements RowMapper<User> {
    
    @Override
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
        User user = new User();
        user.setId(rs.getLong("id"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email"));
        
        Timestamp createdAt = rs.getTimestamp("created_at");
        if (createdAt != null) {
            user.setCreatedAt(createdAt.toLocalDateTime());
        }
        
        return user;
    }
}

@Repository
public class OrderJdbcRepository {
    
    private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;
    
    public OrderJdbcRepository(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
    }
    
    public List<Order> findByUserIdAndStatus(Long userId, OrderStatus status) {
        String sql = """
            SELECT o.id, o.user_id, o.total_amount, o.status, o.created_at,
                   oi.id as item_id, oi.product_name, oi.quantity, oi.price
            FROM orders o
            LEFT JOIN order_items oi ON o.id = oi.order_id
            WHERE o.user_id = :userId AND o.status = :status
            ORDER BY o.created_at DESC
            """;
        
        Map<String, Object> params = Map.of(
            "userId", userId,
            "status", status.name()
        );
        
        return namedParameterJdbcTemplate.query(sql, params, new OrderResultSetExtractor());
    }
    
    public Order save(Order order) {
        if (order.getId() == null) {
            return insertOrder(order);
        } else {
            return updateOrder(order);
        }
    }
    
    private Order insertOrder(Order order) {
        String orderSql = """
            INSERT INTO orders (user_id, total_amount, status, created_at) 
            VALUES (:userId, :totalAmount, :status, :createdAt)
            """;
        
        SqlParameterSource orderParams = new BeanPropertySqlParameterSource(order) {
            @Override
            public Object getValue(String paramName) {
                if ("status".equals(paramName)) {
                    return order.getStatus().name();
                }
                return super.getValue(paramName);
            }
        };
        
        KeyHolder keyHolder = new GeneratedKeyHolder();
        namedParameterJdbcTemplate.update(orderSql, orderParams, keyHolder);
        
        Long orderId = keyHolder.getKey().longValue();
        order.setId(orderId);
        
        // 插入訂單項目
        if (!order.getItems().isEmpty()) {
            insertOrderItems(orderId, order.getItems());
        }
        
        return order;
    }
    
    private void insertOrderItems(Long orderId, List<OrderItem> items) {
        String sql = """
            INSERT INTO order_items (order_id, product_name, quantity, price) 
            VALUES (:orderId, :productName, :quantity, :price)
            """;
        
        List<Map<String, Object>> batchParams = items.stream()
            .map(item -> Map.of(
                "orderId", orderId,
                "productName", item.getProductName(),
                "quantity", item.getQuantity(),
                "price", item.getPrice()
            ))
            .collect(Collectors.toList());
        
        namedParameterJdbcTemplate.batchUpdate(sql, batchParams.toArray(new Map[0]));
    }
}

// ResultSetExtractor 實現
public class OrderResultSetExtractor implements ResultSetExtractor<List<Order>> {
    
    @Override
    public List<Order> extractData(ResultSet rs) throws SQLException, DataAccessException {
        Map<Long, Order> orderMap = new LinkedHashMap<>();
        
        while (rs.next()) {
            Long orderId = rs.getLong("id");
            Order order = orderMap.get(orderId);
            
            if (order == null) {
                order = new Order();
                order.setId(orderId);
                order.setUserId(rs.getLong("user_id"));
                order.setTotalAmount(rs.getBigDecimal("total_amount"));
                order.setStatus(OrderStatus.valueOf(rs.getString("status")));
                order.setCreatedAt(rs.getTimestamp("created_at").toLocalDateTime());
                order.setItems(new ArrayList<>());
                
                orderMap.put(orderId, order);
            }
            
            Long itemId = rs.getLong("item_id");
            if (itemId > 0) {
                OrderItem item = new OrderItem();
                item.setId(itemId);
                item.setProductName(rs.getString("product_name"));
                item.setQuantity(rs.getInt("quantity"));
                item.setPrice(rs.getBigDecimal("price"));
                
                order.getItems().add(item);
            }
        }
        
        return new ArrayList<>(orderMap.values());
    }
}

// JPA 配置
@Configuration
@EnableJpaRepositories(basePackages = "com.tutorial.repository")
@EnableTransactionManagement
public class JpaConfig {
    
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
            DataSource dataSource) {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource);
        em.setPackagesToScan("com.tutorial.model");
        em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
        
        Properties properties = new Properties();
        properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        properties.setProperty("hibernate.hbm2ddl.auto", "validate");
        properties.setProperty("hibernate.show_sql", "true");
        properties.setProperty("hibernate.format_sql", "true");
        properties.setProperty("hibernate.use_sql_comments", "true");
        properties.setProperty("hibernate.jdbc.batch_size", "20");
        properties.setProperty("hibernate.order_inserts", "true");
        properties.setProperty("hibernate.order_updates", "true");
        
        em.setJpaProperties(properties);
        return em;
    }
    
    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
}

// 實體類別
@Entity
@Table(name = "users")
@EntityListeners(AuditingEntityListener.class)
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, length = 100)
    private String name;
    
    @Column(nullable = false, unique = true, length = 255)
    private String email;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private UserStatus status = UserStatus.ACTIVE;
    
    @CreatedDate
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Order> orders = new ArrayList<>();
    
    @ManyToMany
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles = new HashSet<>();
    
    // 建構子、getter、setter
}

@Entity
@Table(name = "orders")
public class Order {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", nullable = false)
    private User user;
    
    @Column(name = "total_amount", nullable = false, precision = 10, scale = 2)
    private BigDecimal totalAmount;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private OrderStatus status;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<OrderItem> items = new ArrayList<>();
    
    @CreatedDate
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
    
    // 建構子、getter、setter
}

// 基本 Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    // 方法名稱查詢
    Optional<User> findByEmail(String email);
    
    List<User> findByNameContainingIgnoreCase(String name);
    
    List<User> findByStatusAndCreatedAtAfter(UserStatus status, LocalDateTime date);
    
    boolean existsByEmail(String email);
    
    long countByStatus(UserStatus status);
    
    void deleteByStatus(UserStatus status);
    
    // 分頁查詢
    Page<User> findByStatus(UserStatus status, Pageable pageable);
    
    Slice<User> findByNameContaining(String name, Pageable pageable);
}

// 自定義查詢
public interface OrderRepository extends JpaRepository<Order, Long> {
    
    // @Query 註解
    @Query("SELECT o FROM Order o WHERE o.user.id = :userId AND o.status = :status")
    List<Order> findByUserAndStatus(@Param("userId") Long userId, 
                                  @Param("status") OrderStatus status);
    
    @Query("SELECT o FROM Order o JOIN FETCH o.items WHERE o.id = :id")
    Optional<Order> findByIdWithItems(@Param("id") Long id);
    
    // 原生 SQL 查詢
    @Query(value = "SELECT * FROM orders WHERE user_id = ?1 AND total_amount > ?2", 
           nativeQuery = true)
    List<Order> findExpensiveOrdersByUser(Long userId, BigDecimal amount);
    
    // 統計查詢
    @Query("SELECT COUNT(o) FROM Order o WHERE o.status = :status")
    long countByStatus(@Param("status") OrderStatus status);
    
    @Query("SELECT SUM(o.totalAmount) FROM Order o WHERE o.user.id = :userId")
    BigDecimal getTotalAmountByUser(@Param("userId") Long userId);
    
    // 更新查詢
    @Modifying
    @Query("UPDATE Order o SET o.status = :status WHERE o.id = :id")
    int updateOrderStatus(@Param("id") Long id, @Param("status") OrderStatus status);
    
    @Modifying
    @Query("DELETE FROM Order o WHERE o.status = :status AND o.createdAt < :date")
    int deleteOldOrdersByStatus(@Param("status") OrderStatus status, 
                               @Param("date") LocalDateTime date);
    
    // 複雜查詢
    @Query("""
        SELECT o FROM Order o 
        WHERE o.user.id = :userId 
        AND o.createdAt BETWEEN :startDate AND :endDate
        AND o.totalAmount >= :minAmount
        ORDER BY o.createdAt DESC
        """)
    List<Order> findOrdersByCriteria(@Param("userId") Long userId,
                                   @Param("startDate") LocalDateTime startDate,
                                   @Param("endDate") LocalDateTime endDate,
                                   @Param("minAmount") BigDecimal minAmount);
}

// 自定義 Repository 介面
public interface UserRepositoryCustom {
    List<User> findUsersWithComplexCriteria(UserSearchCriteria criteria);
    Page<UserStatistics> getUserStatistics(Pageable pageable);
}

// 自定義 Repository 實現
@Repository
public class UserRepositoryCustomImpl implements UserRepositoryCustom {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    @Override
    public List<User> findUsersWithComplexCriteria(UserSearchCriteria criteria) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<User> query = cb.createQuery(User.class);
        Root<User> user = query.from(User.class);
        
        List<Predicate> predicates = new ArrayList<>();
        
        // 動態條件建構
        if (criteria.getName() != null) {
            predicates.add(cb.like(cb.lower(user.get("name")), 
                "%" + criteria.getName().toLowerCase() + "%"));
        }
        
        if (criteria.getEmail() != null) {
            predicates.add(cb.like(cb.lower(user.get("email")), 
                "%" + criteria.getEmail().toLowerCase() + "%"));
        }
        
        if (criteria.getStatus() != null) {
            predicates.add(cb.equal(user.get("status"), criteria.getStatus()));
        }
        
        if (criteria.getCreatedAfter() != null) {
            predicates.add(cb.greaterThanOrEqualTo(user.get("createdAt"), 
                criteria.getCreatedAfter()));
        }
        
        if (criteria.getCreatedBefore() != null) {
            predicates.add(cb.lessThanOrEqualTo(user.get("createdAt"), 
                criteria.getCreatedBefore()));
        }
        
        query.where(predicates.toArray(new Predicate[0]));
        query.orderBy(cb.desc(user.get("createdAt")));
        
        TypedQuery<User> typedQuery = entityManager.createQuery(query);
        
        if (criteria.getMaxResults() != null) {
            typedQuery.setMaxResults(criteria.getMaxResults());
        }
        
        return typedQuery.getResultList();
    }
    
    @Override
    public Page<UserStatistics> getUserStatistics(Pageable pageable) {
        String queryStr = """
            SELECT new com.tutorial.dto.UserStatistics(
                u.id, u.name, u.email, 
                COUNT(o.id), 
                COALESCE(SUM(o.totalAmount), 0)
            )
            FROM User u LEFT JOIN u.orders o
            GROUP BY u.id, u.name, u.email
            """;
        
        TypedQuery<UserStatistics> query = entityManager.createQuery(queryStr, UserStatistics.class);
        query.setFirstResult((int) pageable.getOffset());
        query.setMaxResults(pageable.getPageSize());
        
        List<UserStatistics> content = query.getResultList();
        
        // 計算總數
        String countQueryStr = "SELECT COUNT(DISTINCT u.id) FROM User u";
        Long total = entityManager.createQuery(countQueryStr, Long.class).getSingleResult();
        
        return new PageImpl<>(content, pageable, total);
    }
}

// 合併介面
public interface UserRepository extends JpaRepository<User, Long>, UserRepositoryCustom {
    // 繼承基本方法和自定義方法
}

// DTO 類別
@Data
@AllArgsConstructor
public class UserStatistics {
    private Long userId;
    private String name;
    private String email;
    private Long orderCount;
    private BigDecimal totalOrderAmount;
}

// 搜尋條件類別
@Data
public class UserSearchCriteria {
    private String name;
    private String email;
    private UserStatus status;
    private LocalDateTime createdAfter;
    private LocalDateTime createdBefore;
    private Integer maxResults;
}

// 事務配置
@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    
    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }
    
    // 自定義事務通知器
    @Bean
    public TransactionInterceptor transactionInterceptor(PlatformTransactionManager transactionManager) {
        NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();
        
        // 只讀事務
        RuleBasedTransactionAttribute readOnlyTx = new RuleBasedTransactionAttribute();
        readOnlyTx.setReadOnly(true);
        readOnlyTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
        
        // 讀寫事務
        RuleBasedTransactionAttribute readWriteTx = new RuleBasedTransactionAttribute();
        readWriteTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        readWriteTx.setIsolationLevel(TransactionDefinition.ISOLATION_DEFAULT);
        readWriteTx.setTimeout(30);
        
        // 方法名稱映射
        source.addTransactionalMethod("get*", readOnlyTx);
        source.addTransactionalMethod("find*", readOnlyTx);
        source.addTransactionalMethod("query*", readOnlyTx);
        source.addTransactionalMethod("count*", readOnlyTx);
        source.addTransactionalMethod("*", readWriteTx);
        
        return new TransactionInterceptor(transactionManager, source);
    }
}

// 服務層事務管理
@Service
@Transactional(readOnly = true)
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final UserRepository userRepository;
    private final PaymentService paymentService;
    private final EmailService emailService;
    
    public OrderService(OrderRepository orderRepository,
                       UserRepository userRepository,
                       PaymentService paymentService,
                       EmailService emailService) {
        this.orderRepository = orderRepository;
        this.userRepository = userRepository;
        this.paymentService = paymentService;
        this.emailService = emailService;
    }
    
    // 只讀事務
    public Order findById(Long id) {
        return orderRepository.findById(id)
            .orElseThrow(() -> new OrderNotFoundException("訂單不存在: " + id));
    }
    
    public Page<Order> findUserOrders(Long userId, Pageable pageable) {
        return orderRepository.findByUserId(userId, pageable);
    }
    
    // 讀寫事務
    @Transactional
    public Order createOrder(Long userId, CreateOrderRequest request) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException("用戶不存在: " + userId));
        
        Order order = new Order();
        order.setUser(user);
        order.setTotalAmount(request.getTotalAmount());
        order.setStatus(OrderStatus.PENDING);
        
        // 建立訂單項目
        List<OrderItem> items = request.getItems().stream()
            .map(itemRequest -> {
                OrderItem item = new OrderItem();
                item.setOrder(order);
                item.setProductName(itemRequest.getProductName());
                item.setQuantity(itemRequest.getQuantity());
                item.setPrice(itemRequest.getPrice());
                return item;
            })
            .collect(Collectors.toList());
        
        order.setItems(items);
        Order savedOrder = orderRepository.save(order);
        
        // 發送通知郵件（不影響事務）
        emailService.sendOrderConfirmation(savedOrder);
        
        return savedOrder;
    }
    
    // 複雜事務處理
    @Transactional(
        isolation = Isolation.REPEATABLE_READ,
        timeout = 60,
        rollbackFor = {Exception.class},
        noRollbackFor = {EmailException.class}
    )
    public Order processOrder(Long orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException("訂單不存在: " + orderId));
        
        if (order.getStatus() != OrderStatus.PENDING) {
            throw new InvalidOrderStatusException("訂單狀態不正確");
        }
        
        try {
            // 處理付款
            PaymentResult paymentResult = paymentService.processPayment(order);
            
            if (paymentResult.isSuccess()) {
                order.setStatus(OrderStatus.CONFIRMED);
                order = orderRepository.save(order);
                
                // 發送確認郵件（如果失敗不影響事務）
                try {
                    emailService.sendOrderConfirmation(order);
                } catch (EmailException e) {
                    // 記錄日誌但不回滾事務
                    logger.warn("發送確認郵件失敗: {}", e.getMessage());
                }
            } else {
                order.setStatus(OrderStatus.FAILED);
                order = orderRepository.save(order);
                throw new PaymentFailedException("付款失敗: " + paymentResult.getErrorMessage());
            }
            
        } catch (PaymentException e) {
            order.setStatus(OrderStatus.FAILED);
            orderRepository.save(order);
            throw e;
        }
        
        return order;
    }
    
    // 事務傳播示例
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logOrderActivity(Long orderId, String activity) {
        // 獨立事務記錄活動日誌
        OrderLog log = new OrderLog();
        log.setOrderId(orderId);
        log.setActivity(activity);
        log.setTimestamp(LocalDateTime.now());
        orderLogRepository.save(log);
    }
}

@Service
public class BatchProcessingService {
    
    private final PlatformTransactionManager transactionManager;
    private final OrderRepository orderRepository;
    
    public BatchProcessingService(PlatformTransactionManager transactionManager,
                                OrderRepository orderRepository) {
        this.transactionManager = transactionManager;
        this.orderRepository = orderRepository;
    }
    
    public void processBatchOrders(List<Order> orders) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        def.setTimeout(300); // 5 分鐘超時
        
        TransactionStatus status = transactionManager.getTransaction(def);
        
        try {
            for (Order order : orders) {
                processOrder(order);
            }
            
            transactionManager.commit(status);
            logger.info("批次處理完成，處理 {} 筆訂單", orders.size());
            
        } catch (Exception e) {
            transactionManager.rollback(status);
            logger.error("批次處理失敗，回滾事務", e);
            throw new BatchProcessingException("批次處理失敗", e);
        }
    }
    
    public void processOrdersWithSavepoint(List<Order> orders) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);
        
        try {
            for (int i = 0; i < orders.size(); i++) {
                Object savepoint = status.createSavepoint();
                
                try {
                    processOrder(orders.get(i));
                } catch (Exception e) {
                    logger.warn("處理訂單 {} 失敗，回滾到保存點", orders.get(i).getId(), e);
                    status.rollbackToSavepoint(savepoint);
                }
                
                status.releaseSavepoint(savepoint);
            }
            
            transactionManager.commit(status);
            
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
    
    private void processOrder(Order order) {
        // 處理訂單邏輯
        order.setStatus(OrderStatus.PROCESSED);
        orderRepository.save(order);
    }
}

// 完整的資料存取層實現
@Service
@Transactional(readOnly = true)
public class UserService {
    
    private final UserRepository userRepository;
    private final RoleRepository roleRepository;
    private final AuditService auditService;
    
    public UserService(UserRepository userRepository,
                      RoleRepository roleRepository,
                      AuditService auditService) {
        this.userRepository = userRepository;
        this.roleRepository = roleRepository;
        this.auditService = auditService;
    }
    
    public Page<User> findUsers(UserSearchCriteria criteria, Pageable pageable) {
        if (criteria.hasComplexCriteria()) {
            // 使用自定義查詢
            List<User> users = userRepository.findUsersWithComplexCriteria(criteria);
            return new PageImpl<>(users, pageable, users.size());
        } else {
            // 使用基本查詢
            return userRepository.findByStatus(criteria.getStatus(), pageable);
        }
    }
    
    @Transactional
    public User createUser(CreateUserRequest request) {
        // 檢查郵箱是否已存在
        if (userRepository.existsByEmail(request.getEmail())) {
            throw new EmailAlreadyExistsException("郵箱已存在: " + request.getEmail());
        }
        
        User user = new User();
        user.setName(request.getName());
        user.setEmail(request.getEmail());
        user.setStatus(UserStatus.ACTIVE);
        
        // 設定默認角色
        Role defaultRole = roleRepository.findByName("USER")
            .orElseThrow(() -> new RoleNotFoundException("默認角色不存在"));
        user.getRoles().add(defaultRole);
        
        User savedUser = userRepository.save(user);
        
        // 記錄審計日誌
        auditService.logUserCreation(savedUser.getId());
        
        return savedUser;
    }
    
    @Transactional
    public void assignRole(Long userId, String roleName) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException("用戶不存在: " + userId));
        
        Role role = roleRepository.findByName(roleName)
            .orElseThrow(() -> new RoleNotFoundException("角色不存在: " + roleName));
        
        if (user.getRoles().contains(role)) {
            throw new RoleAlreadyAssignedException("用戶已擁有該角色");
        }
        
        user.getRoles().add(role);
        userRepository.save(user);
        
        auditService.logRoleAssignment(userId, role.getId());
    }
}

@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig {
    
    private final UserDetailsService userDetailsService;
    private final PasswordEncoder passwordEncoder;
    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    private final JwtRequestFilter jwtRequestFilter;
    
    public SecurityConfig(UserDetailsService userDetailsService,
                         PasswordEncoder passwordEncoder,
                         JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint,
                         JwtRequestFilter jwtRequestFilter) {
        this.userDetailsService = userDetailsService;
        this.passwordEncoder = passwordEncoder;
        this.jwtAuthenticationEntryPoint = jwtAuthenticationEntryPoint;
        this.jwtRequestFilter = jwtRequestFilter;
    }
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            // CSRF 配置
            .csrf(csrf -> csrf
                .ignoringRequestMatchers("/api/**")
                .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
            )
            
            // CORS 配置
            .cors(cors -> cors.configurationSource(corsConfigurationSource()))
            
            // 會話管理
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            
            // 異常處理
            .exceptionHandling(exceptions -> exceptions
                .authenticationEntryPoint(jwtAuthenticationEntryPoint)
                .accessDeniedHandler(customAccessDeniedHandler())
            )
            
            // 授權規則
            .authorizeHttpRequests(authz -> authz
                // 公開端點
                .requestMatchers("/api/auth/**", "/api/public/**").permitAll()
                .requestMatchers("/swagger-ui/**", "/v3/api-docs/**").permitAll()
                .requestMatchers(HttpMethod.GET, "/api/products/**").permitAll()
                
                // 需要認證的端點
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers(HttpMethod.POST, "/api/products/**").hasAnyRole("ADMIN", "MANAGER")
                .requestMatchers(HttpMethod.PUT, "/api/products/**").hasAnyRole("ADMIN", "MANAGER")
                .requestMatchers(HttpMethod.DELETE, "/api/products/**").hasRole("ADMIN")
                
                // 其他請求需要認證
                .anyRequest().authenticated()
            )
            
            // 添加 JWT 過濾器
            .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class)
            
            // HTTP Basic 認證（可選）
            .httpBasic(Customizer.withDefaults())
            
            // 表單登入（可選）
            .formLogin(form -> form
                .loginPage("/login")
                .loginProcessingUrl("/api/auth/login")
                .defaultSuccessUrl("/dashboard")
                .failureUrl("/login?error=true")
                .permitAll()
            )
            
            // 登出配置
            .logout(logout -> logout
                .logoutUrl("/api/auth/logout")
                .logoutSuccessUrl("/")
                .invalidateHttpSession(true)
                .deleteCookies("JSESSIONID")
                .permitAll()
            );
        
        return http.build();
    }
    
    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration authConfig) throws Exception {
        return authConfig.getAuthenticationManager();
    }
    
    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userDetailsService);
        authProvider.setPasswordEncoder(passwordEncoder);
        return authProvider;
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);
    }
    
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOriginPatterns(Arrays.asList("http://localhost:3000", "https://*.example.com"));
        configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
        configuration.setAllowedHeaders(Arrays.asList("*"));
        configuration.setAllowCredentials(true);
        
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
    
    @Bean
    public AccessDeniedHandler customAccessDeniedHandler() {
        return new CustomAccessDeniedHandler();
    }
}

@Service
public class CustomUserDetailsService implements UserDetailsService {
    
    private final UserRepository userRepository;
    
    public CustomUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Override
    @Transactional(readOnly = true)
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByEmail(username)
            .orElseThrow(() -> new UsernameNotFoundException("用戶不存在: " + username));
        
        if (!user.isActive()) {
            throw new DisabledException("用戶帳號已被停用");
        }
        
        return UserPrincipal.create(user);
    }
}

// 自定義 UserDetails 實現
public class UserPrincipal implements UserDetails {
    
    private Long id;
    private String name;
    private String email;
    private String password;
    private Collection<? extends GrantedAuthority> authorities;
    private boolean enabled;
    private boolean accountNonExpired;
    private boolean accountNonLocked;
    private boolean credentialsNonExpired;
    
    public UserPrincipal(Long id, String name, String email, String password,
                        Collection<? extends GrantedAuthority> authorities,
                        boolean enabled, boolean accountNonExpired,
                        boolean accountNonLocked, boolean credentialsNonExpired) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.password = password;
        this.authorities = authorities;
        this.enabled = enabled;
        this.accountNonExpired = accountNonExpired;
        this.accountNonLocked = accountNonLocked;
        this.credentialsNonExpired = credentialsNonExpired;
    }
    
    public static UserPrincipal create(User user) {
        List<GrantedAuthority> authorities = user.getRoles().stream()
            .map(role -> new SimpleGrantedAuthority("ROLE_" + role.getName()))
            .collect(Collectors.toList());
        
        return new UserPrincipal(
            user.getId(),
            user.getName(),
            user.getEmail(),
            user.getPassword(),
            authorities,
            user.getStatus() == UserStatus.ACTIVE,
            true, // accountNonExpired
            true, // accountNonLocked
            true  // credentialsNonExpired
        );
    }
    
    // UserDetails 介面方法實現
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }
    
    @Override
    public String getPassword() {
        return password;
    }
    
    @Override
    public String getUsername() {
        return email;
    }
    
    @Override
    public boolean isAccountNonExpired() {
        return accountNonExpired;
    }
    
    @Override
    public boolean isAccountNonLocked() {
        return accountNonLocked;
    }
    
    @Override
    public boolean isCredentialsNonExpired() {
        return credentialsNonExpired;
    }
    
    @Override
    public boolean isEnabled() {
        return enabled;
    }
    
    // 額外的 getter 方法
    public Long getId() {
        return id;
    }
    
    public String getName() {
        return name;
    }
    
    public String getEmail() {
        return email;
    }
}

@Component
public class JwtTokenUtil {
    
    private static final Logger logger = LoggerFactory.getLogger(JwtTokenUtil.class);
    
    @Value("${app.jwtSecret}")
    private String jwtSecret;
    
    @Value("${app.jwtExpirationInMs}")
    private int jwtExpirationInMs;
    
    public String generateToken(UserPrincipal userPrincipal) {
        Date expiryDate = new Date(System.currentTimeMillis() + jwtExpirationInMs);
        
        return Jwts.builder()
            .setSubject(userPrincipal.getId().toString())
            .claim("email", userPrincipal.getEmail())
            .claim("name", userPrincipal.getName())
            .claim("authorities", userPrincipal.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()))
            .setIssuedAt(new Date())
            .setExpiration(expiryDate)
            .signWith(SignatureAlgorithm.HS512, jwtSecret)
            .compact();
    }
    
    public String generateRefreshToken(UserPrincipal userPrincipal) {
        Date expiryDate = new Date(System.currentTimeMillis() + jwtExpirationInMs * 7); // 7倍時間
        
        return Jwts.builder()
            .setSubject(userPrincipal.getId().toString())
            .claim("type", "refresh")
            .setIssuedAt(new Date())
            .setExpiration(expiryDate)
            .signWith(SignatureAlgorithm.HS512, jwtSecret)
            .compact();
    }
    
    public Long getUserIdFromToken(String token) {
        Claims claims = Jwts.parser()
            .setSigningKey(jwtSecret)
            .parseClaimsJws(token)
            .getBody();
        
        return Long.parseLong(claims.getSubject());
    }
    
    public boolean validateToken(String authToken) {
        try {
            Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(authToken);
            return true;
        } catch (SignatureException ex) {
            logger.error("無效的 JWT 簽名");
        } catch (MalformedJwtException ex) {
            logger.error("無效的 JWT 令牌");
        } catch (ExpiredJwtException ex) {
            logger.error("JWT 令牌已過期");
        } catch (UnsupportedJwtException ex) {
            logger.error("不支援的 JWT 令牌");
        } catch (IllegalArgumentException ex) {
            logger.error("JWT 聲明字串為空");
        }
        return false;
    }
    
    public Date getExpirationDateFromToken(String token) {
        Claims claims = Jwts.parser()
            .setSigningKey(jwtSecret)
            .parseClaimsJws(token)
            .getBody();
        
        return claims.getExpiration();
    }
    
    public boolean isTokenExpired(String token) {
        Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }
}

@Component
public class JwtRequestFilter extends OncePerRequestFilter {
    
    private static final Logger logger = LoggerFactory.getLogger(JwtRequestFilter.class);
    
    private final UserDetailsService userDetailsService;
    private final JwtTokenUtil jwtTokenUtil;
    
    public JwtRequestFilter(UserDetailsService userDetailsService, JwtTokenUtil jwtTokenUtil) {
        this.userDetailsService = userDetailsService;
        this.jwtTokenUtil = jwtTokenUtil;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain chain) throws ServletException, IOException {
        
        final String requestTokenHeader = request.getHeader("Authorization");
        
        String username = null;
        String jwtToken = null;
        
        // JWT 令牌格式為 "Bearer token"
        if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) {
            jwtToken = requestTokenHeader.substring(7);
            try {
                username = jwtTokenUtil.getUserIdFromToken(jwtToken).toString();
            } catch (IllegalArgumentException e) {
                logger.warn("無法獲取 JWT 令牌");
            } catch (ExpiredJwtException e) {
                logger.warn("JWT 令牌已過期");
            }
        } else {
            logger.debug("JWT 令牌不是以 Bearer 開頭");
        }
        
        // 驗證令牌
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            
            if (jwtTokenUtil.validateToken(jwtToken)) {
                UsernamePasswordAuthenticationToken authToken = 
                    new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }
        
        chain.doFilter(request, response);
    }
}

// JWT 認證入口點
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
    
    private static final Logger logger = LoggerFactory.getLogger(JwtAuthenticationEntryPoint.class);
    
    @Override
    public void commence(HttpServletRequest request, 
                        HttpServletResponse response,
                        AuthenticationException authException) throws IOException, ServletException {
        
        logger.error("未授權的請求 - {}", authException.getMessage());
        
        response.setContentType("application/json;charset=UTF-8");
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> errorResponse = Map.of(
            "timestamp", LocalDateTime.now().toString(),
            "status", HttpStatus.UNAUTHORIZED.value(),
            "error", "Unauthorized",
            "message", "請先登入",
            "path", request.getRequestURI()
        );
        
        response.getWriter().write(mapper.writeValueAsString(errorResponse));
    }
}

@RestController
@RequestMapping("/api/auth")
@Validated
public class AuthController {
    
    private static final Logger logger = LoggerFactory.getLogger(AuthController.class);
    
    private final AuthenticationManager authenticationManager;
    private final UserService userService;
    private final JwtTokenUtil jwtTokenUtil;
    private final PasswordEncoder passwordEncoder;
    
    public AuthController(AuthenticationManager authenticationManager,
                         UserService userService,
                         JwtTokenUtil jwtTokenUtil,
                         PasswordEncoder passwordEncoder) {
        this.authenticationManager = authenticationManager;
        this.userService = userService;
        this.jwtTokenUtil = jwtTokenUtil;
        this.passwordEncoder = passwordEncoder;
    }
    
    @PostMapping("/login")
    public ResponseEntity<JwtAuthenticationResponse> authenticateUser(
            @Valid @RequestBody LoginRequest loginRequest) {
        
        Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(
                loginRequest.getEmail(),
                loginRequest.getPassword()
            )
        );
        
        SecurityContextHolder.getContext().setAuthentication(authentication);
        
        UserPrincipal userPrincipal = (UserPrincipal) authentication.getPrincipal();
        String jwt = jwtTokenUtil.generateToken(userPrincipal);
        String refreshToken = jwtTokenUtil.generateRefreshToken(userPrincipal);
        
        logger.info("用戶登入成功: {}", userPrincipal.getEmail());
        
        return ResponseEntity.ok(new JwtAuthenticationResponse(
            jwt, 
            refreshToken,
            "Bearer",
            jwtTokenUtil.getExpirationDateFromToken(jwt),
            UserDTO.from(userPrincipal)
        ));
    }
    
    @PostMapping("/register")
    public ResponseEntity<ApiResponse> registerUser(@Valid @RequestBody SignUpRequest signUpRequest) {
        
        if (userService.existsByEmail(signUpRequest.getEmail())) {
            return ResponseEntity.badRequest()
                .body(new ApiResponse(false, "郵箱已被使用！"));
        }
        
        // 創建新用戶
        User user = new User();
        user.setName(signUpRequest.getName());
        user.setEmail(signUpRequest.getEmail());
        user.setPassword(passwordEncoder.encode(signUpRequest.getPassword()));
        user.setStatus(UserStatus.ACTIVE);
        
        User result = userService.save(user);
        
        logger.info("新用戶註冊成功: {}", result.getEmail());
        
        return ResponseEntity.ok(new ApiResponse(true, "用戶註冊成功"));
    }
    
    @PostMapping("/refresh")
    public ResponseEntity<JwtAuthenticationResponse> refreshToken(
            @Valid @RequestBody RefreshTokenRequest refreshTokenRequest) {
        
        String refreshToken = refreshTokenRequest.getRefreshToken();
        
        if (!jwtTokenUtil.validateToken(refreshToken)) {
            throw new TokenRefreshException("無效的刷新令牌");
        }
        
        Long userId = jwtTokenUtil.getUserIdFromToken(refreshToken);
        User user = userService.findById(userId);
        UserPrincipal userPrincipal = UserPrincipal.create(user);
        
        String newToken = jwtTokenUtil.generateToken(userPrincipal);
        String newRefreshToken = jwtTokenUtil.generateRefreshToken(userPrincipal);
        
        return ResponseEntity.ok(new JwtAuthenticationResponse(
            newToken,
            newRefreshToken,
            "Bearer",
            jwtTokenUtil.getExpirationDateFromToken(newToken),
            UserDTO.from(userPrincipal)
        ));
    }
    
    @PostMapping("/logout")
    @PreAuthorize("hasRole('USER')")
    public ResponseEntity<ApiResponse> logout(HttpServletRequest request) {
        // 在實際應用中，可以將令牌加入黑名單
        SecurityContextHolder.clearContext();
        
        logger.info("用戶登出成功");
        
        return ResponseEntity.ok(new ApiResponse(true, "登出成功"));
    }
    
    @GetMapping("/me")
    @PreAuthorize("hasRole('USER')")
    public ResponseEntity<UserDTO> getCurrentUser(@CurrentUser UserPrincipal currentUser) {
        return ResponseEntity.ok(UserDTO.from(currentUser));
    }
}

// DTO 類別
@Data
@AllArgsConstructor
public class JwtAuthenticationResponse {
    private String accessToken;
    private String refreshToken;
    private String tokenType;
    private Date expiryDate;
    private UserDTO user;
}

@Data
public class LoginRequest {
    @NotBlank
    @Email
    private String email;
    
    @NotBlank
    @Size(min = 6, max = 20)
    private String password;
}

@Data
public class SignUpRequest {
    @NotBlank
    @Size(min = 2, max = 40)
    private String name;
    
    @NotBlank
    @Size(max = 40)
    @Email
    private String email;
    
    @NotBlank
    @Size(min = 6, max = 20)
    private String password;
}

@Data
public class RefreshTokenRequest {
    @NotBlank
    private String refreshToken;
}

@Data
@AllArgsConstructor
public class ApiResponse {
    private Boolean success;
    private String message;
}

@Service
@PreAuthorize("hasRole('USER')")
public class DocumentService {
    
    private final DocumentRepository documentRepository;
    
    public DocumentService(DocumentRepository documentRepository) {
        this.documentRepository = documentRepository;
    }
    
    // 檢查用戶是否為文檔擁有者
    @PreAuthorize("hasRole('ADMIN') or @documentSecurityService.isOwner(#id, authentication.principal.id)")
    public Document getDocument(Long id) {
        return documentRepository.findById(id)
            .orElseThrow(() -> new DocumentNotFoundException("文檔不存在: " + id));
    }
    
    // 檢查返回的物件是否屬於當前用戶
    @PostAuthorize("returnObject.ownerId == authentication.principal.id or hasRole('ADMIN')")
    public Document findDocument(Long id) {
        return documentRepository.findById(id).orElse(null);
    }
    
    // 過濾集合中的元素
    @PostFilter("filterObject.ownerId == authentication.principal.id or hasRole('ADMIN')")
    public List<Document> findAllDocuments() {
        return documentRepository.findAll();
    }
    
    // 過濾輸入參數
    @PreFilter("filterObject.ownerId == authentication.principal.id")
    public void deleteDocuments(List<Document> documents) {
        documentRepository.deleteAll(documents);
    }
    
    // 複雜的權限檢查
    @PreAuthorize("hasRole('ADMIN') or " +
                 "(hasRole('MANAGER') and @documentSecurityService.isInSameDepartment(#id, authentication.principal.id)) or " +
                 "(@documentSecurityService.isOwner(#id, authentication.principal.id) and @documentSecurityService.canModify(#id))")
    public Document updateDocument(Long id, UpdateDocumentRequest request) {
        Document document = getDocument(id);
        document.setTitle(request.getTitle());
        document.setContent(request.getContent());
        return documentRepository.save(document);
    }
    
    // 使用 @Secured 註解
    @Secured({"ROLE_ADMIN", "ROLE_MANAGER"})
    public void deleteDocument(Long id) {
        Document document = getDocument(id);
        documentRepository.delete(document);
    }
    
    // 使用 @RolesAllowed 註解 (JSR-250)
    @RolesAllowed({"ADMIN", "MANAGER"})
    public List<Document> getAllDocuments() {
        return documentRepository.findAll();
    }
}

// 自定義安全服務
@Service("documentSecurityService")
public class DocumentSecurityService {
    
    private final DocumentRepository documentRepository;
    private final UserRepository userRepository;
    
    public DocumentSecurityService(DocumentRepository documentRepository,
                                 UserRepository userRepository) {
        this.documentRepository = documentRepository;
        this.userRepository = userRepository;
    }
    
    public boolean isOwner(Long documentId, Long userId) {
        return documentRepository.findById(documentId)
            .map(document -> document.getOwnerId().equals(userId))
            .orElse(false);
    }
    
    public boolean canModify(Long documentId) {
        return documentRepository.findById(documentId)
            .map(document -> document.getStatus() == DocumentStatus.DRAFT)
            .orElse(false);
    }
    
    public boolean isInSameDepartment(Long documentId, Long userId) {
        Optional<Document> documentOpt = documentRepository.findById(documentId);
        Optional<User> userOpt = userRepository.findById(userId);
        
        if (documentOpt.isPresent() && userOpt.isPresent()) {
            Document document = documentOpt.get();
            User user = userOpt.get();
            
            User owner = userRepository.findById(document.getOwnerId()).orElse(null);
            return owner != null && owner.getDepartmentId().equals(user.getDepartmentId());
        }
        
        return false;
    }
    
    public boolean hasPermission(UserPrincipal user, Document document, String permission) {
        // 實現複雜的權限邏輯
        if (user.getAuthorities().stream()
            .anyMatch(auth -> auth.getAuthority().equals("ROLE_ADMIN"))) {
            return true;
        }
        
        if (document.getOwnerId().equals(user.getId())) {
            return true;
        }
        
        // 檢查共享權限
        return checkSharedPermission(user.getId(), document.getId(), permission);
    }
    
    private boolean checkSharedPermission(Long userId, Long documentId, String permission) {
        // 實現共享權限檢查邏輯
        return false;
    }
}

// 完整的安全配置範例
@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
public class ProductionSecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable()) // API 模式停用 CSRF
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .authorizeHttpRequests(authz -> authz
                // 公開 API
                .requestMatchers("/api/public/**", "/api/auth/**").permitAll()
                .requestMatchers("/actuator/health", "/actuator/info").permitAll()
                
                // 管理員 API
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers("/actuator/**").hasRole("ADMIN")
                
                // 業務 API
                .requestMatchers(HttpMethod.GET, "/api/products/**").hasAnyRole("USER", "MANAGER", "ADMIN")
                .requestMatchers(HttpMethod.POST, "/api/orders/**").hasAnyRole("USER", "MANAGER", "ADMIN")
                .requestMatchers(HttpMethod.PUT, "/api/products/**").hasAnyRole("MANAGER", "ADMIN")
                
                // 其他請求需要認證
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt.jwtDecoder(jwtDecoder()))
            )
            .exceptionHandling(exceptions -> exceptions
                .authenticationEntryPoint(new CustomAuthenticationEntryPoint())
                .accessDeniedHandler(new CustomAccessDeniedHandler())
            );
        
        return http.build();
    }
    
    @Bean
    public JwtDecoder jwtDecoder() {
        // 配置 JWT 解碼器
        return NimbusJwtDecoder.withJwkSetUri("https://your-auth-server/.well-known/jwks.json").build();
    }
}

// 審計和日誌
@Component
@Slf4j
public class SecurityAuditListener {
    
    @EventListener
    public void handleAuthenticationSuccess(AbstractAuthenticationEvent event) {
        Authentication authentication = event.getAuthentication();
        log.info("認證成功: user={}, authorities={}", 
                authentication.getName(), 
                authentication.getAuthorities());
    }
    
    @EventListener
    public void handleAuthenticationFailure(AbstractAuthenticationFailureEvent event) {
        Authentication authentication = event.getAuthentication();
        Exception exception = event.getException();
        log.warn("認證失敗: user={}, reason={}", 
                authentication.getName(), 
                exception.getMessage());
    }
    
    @EventListener
    public void handleAccessDenied(AuthorizationDeniedEvent event) {
        log.warn("存取被拒絕: user={}, resource={}", 
                event.getAuthentication().getName(),
                event.getAuthorizationDecision());
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <!-- Spring Boot Parent -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
        <relativePath/>
    </parent>
    
    <groupId>com.tutorial</groupId>
    <artifactId>spring-boot-tutorial</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    
    <name>Spring Boot Tutorial</name>
    <description>Spring Boot 教學專案</description>
    
    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <dependencies>
        <!-- Spring Boot Web Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Spring Boot Data JPA Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        
        <!-- Spring Boot Security Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        
        <!-- Spring Boot Validation Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        
        <!-- Spring Boot Actuator -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        
        <!-- Spring Boot Test Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- MySQL Driver -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        
        <!-- H2 Database (for testing) -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <!-- Spring Boot Maven Plugin -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
            
            <!-- Maven Compiler Plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

@SpringBootApplication
@EnableJpaAuditing
public class SpringBootTutorialApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(SpringBootTutorialApplication.class, args);
    }
    
    // 自定義 CommandLineRunner
    @Bean
    public CommandLineRunner initData(UserRepository userRepository, 
                                    PasswordEncoder passwordEncoder) {
        return args -> {
            // 檢查是否已有管理員用戶
            if (!userRepository.existsByEmail("admin@example.com")) {
                User admin = new User();
                admin.setName("管理員");
                admin.setEmail("admin@example.com");
                admin.setPassword(passwordEncoder.encode("admin123"));
                admin.setStatus(UserStatus.ACTIVE);
                userRepository.save(admin);
                
                System.out.println("已創建預設管理員用戶");
            }
        };
    }
    
    // 自定義應用程式啟動監聽器
    @EventListener
    public void handleApplicationReady(ApplicationReadyEvent event) {
        System.out.println("應用程式啟動完成！");
        System.out.println("可用的端點：");
        System.out.println("- http://localhost:8080/api/health");
        System.out.println("- http://localhost:8080/actuator/health");
    }
}

// 分離的配置類別
@Configuration
@ConditionalOnProperty(name = "app.async.enabled", havingValue = "true", matchIfMissing = true)
@EnableAsync
public class AsyncConfig {
    
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }
}

@Configuration
@EnableScheduling
@ConditionalOnProperty(name = "app.scheduling.enabled", havingValue = "true")
public class SchedulingConfig {
    
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5);
        scheduler.setThreadNamePrefix("scheduler-");
        scheduler.initialize();
        return scheduler;
    }
}

# application.yml
spring:
  application:
    name: spring-boot-tutorial
    
  profiles:
    active: development
    
  datasource:
    url: jdbc:mysql://localhost:3306/tutorial_db?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    username: ${DB_USERNAME:root}
    password: ${DB_PASSWORD:password}
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      idle-timeout: 300000
      connection-timeout: 20000
      leak-detection-threshold: 60000
      
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        format_sql: true
        use_sql_comments: true
        jdbc:
          batch_size: 20
        order_inserts: true
        order_updates: true
        
  jackson:
    serialization:
      write-dates-as-timestamps: false
    time-zone: Asia/Taipei
    date-format: yyyy-MM-dd HH:mm:ss
    
  security:
    user:
      name: admin
      password: admin
      roles: ADMIN
      
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 50MB
      
server:
  port: 8080
  servlet:
    context-path: /
    encoding:
      charset: UTF-8
      enabled: true
      force: true
  compression:
    enabled: true
    mime-types: text/html,text/xml,text/plain,text/css,text/javascript,application/javascript,application/json
    min-response-size: 1024
    
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
      base-path: /actuator
  endpoint:
    health:
      show-details: when-authorized
    metrics:
      enabled: true
  metrics:
    export:
      prometheus:
        enabled: true
        
logging:
  level:
    com.tutorial: DEBUG
    org.springframework.security: DEBUG
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
  file:
    name: logs/application.log
    max-size: 10MB
    max-history: 30
    
app:
  jwt:
    secret: ${JWT_SECRET:mySecretKey}
    expiration: 86400000 # 24 hours
  cors:
    allowed-origins: http://localhost:3000,http://localhost:3001
  async:
    enabled: true
  scheduling:
    enabled: true
  features:
    user-registration: true
    email-notifications: true
    file-upload: true

---
# Development Profile
spring:
  config:
    activate:
      on-profile: development
      
  datasource:
    url: jdbc:h2:mem:devdb
    username: sa
    password: 
    driver-class-name: org.h2.Driver
    
  h2:
    console:
      enabled: true
      path: /h2-console
      
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
    
logging:
  level:
    root: INFO
    com.tutorial: DEBUG

---
# Test Profile  
spring:
  config:
    activate:
      on-profile: test
      
  datasource:
    url: jdbc:h2:mem:testdb
    username: sa
    password:
    driver-class-name: org.h2.Driver
    
  jpa:
    hibernate:
      ddl-auto: create-drop
      
app:
  features:
    email-notifications: false

---
# Production Profile
spring:
  config:
    activate:
      on-profile: production
      
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
    
logging:
  level:
    root: WARN
    com.tutorial: INFO
    
management:
  endpoints:
    web:
      exposure:
        include: health,info

@ConfigurationProperties(prefix = "app")
@Data
@Component
@Validated
public class AppProperties {
    
    private Jwt jwt = new Jwt();
    private Cors cors = new Cors();
    private Features features = new Features();
    private Upload upload = new Upload();
    
    @Data
    public static class Jwt {
        @NotBlank
        private String secret;
        
        @Min(1)
        private long expiration = 86400000; // 24 hours
    }
    
    @Data
    public static class Cors {
        private List<String> allowedOrigins = Arrays.asList("http://localhost:3000");
        private List<String> allowedMethods = Arrays.asList("GET", "POST", "PUT", "DELETE");
        private List<String> allowedHeaders = Arrays.asList("*");
        private boolean allowCredentials = true;
    }
    
    @Data
    public static class Features {
        private boolean userRegistration = true;
        private boolean emailNotifications = true;
        private boolean fileUpload = true;
        private boolean socialLogin = false;
    }
    
    @Data
    public static class Upload {
        @Size(max = 20)
        private String maxFileSize = "10MB";
        
        @Size(max = 50)
        private String maxRequestSize = "50MB";
        
        private List<String> allowedTypes = Arrays.asList(
            "image/jpeg", "image/png", "image/gif", "application/pdf"
        );
    }
}

// 條件配置類別
@Configuration
@ConditionalOnProperty(name = "app.features.email-notifications", havingValue = "true")
public class EmailConfig {
    
    @Bean
    @ConditionalOnMissingBean
    public EmailService emailService() {
        return new SmtpEmailService();
    }
}

@Configuration
@ConditionalOnProperty(name = "app.features.file-upload", havingValue = "true")
public class FileUploadConfig {
    
    @Bean
    public MultipartConfigElement multipartConfigElement(AppProperties appProperties) {
        MultipartConfigFactory factory = new MultipartConfigFactory();
        factory.setMaxFileSize(DataSize.parse(appProperties.getUpload().getMaxFileSize()));
        factory.setMaxRequestSize(DataSize.parse(appProperties.getUpload().getMaxRequestSize()));
        return factory.createMultipartConfig();
    }
}

// 自動配置類別
@Configuration
@ConditionalOnClass(RedisTemplate.class)
@ConditionalOnProperty(name = "app.cache.redis.enabled", havingValue = "true")
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public LettuceConnectionFactory redisConnectionFactory(RedisProperties properties) {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(properties.getHost());
        config.setPort(properties.getPort());
        config.setDatabase(properties.getDatabase());
        
        if (properties.getPassword() != null) {
            config.setPassword(properties.getPassword());
        }
        
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            .commandTimeout(Duration.ofSeconds(properties.getTimeout()))
            .poolConfig(connectionPoolConfig(properties.getPool()))
            .build();
            
        return new LettuceConnectionFactory(config, clientConfig);
    }
    
    @Bean
    @ConditionalOnMissingBean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        
        // 設定序列化器
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        
        template.afterPropertiesSet();
        return template;
    }
    
    @Bean
    @ConditionalOnMissingBean
    public CacheManager cacheManager(LettuceConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1))
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new Jackson2JsonRedisSerializer<>(Object.class)));
                
        return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(config)
            .build();
    }
    
    private GenericObjectPoolConfig<?> connectionPoolConfig(RedisProperties.Pool pool) {
        GenericObjectPoolConfig<?> config = new GenericObjectPoolConfig<>();
        config.setMaxTotal(pool.getMaxActive());
        config.setMaxIdle(pool.getMaxIdle());
        config.setMinIdle(pool.getMinIdle());
        config.setMaxWaitMillis(pool.getMaxWait().toMillis());
        return config;
    }
}

// 配置屬性
@ConfigurationProperties(prefix = "app.cache.redis")
@Data
public class RedisProperties {
    
    private boolean enabled = false;
    private String host = "localhost";
    private int port = 6379;
    private String password;
    private int database = 0;
    private Duration timeout = Duration.ofSeconds(5);
    private Pool pool = new Pool();
    
    @Data
    public static class Pool {
        private int maxActive = 8;
        private int maxIdle = 8;
        private int minIdle = 0;
        private Duration maxWait = Duration.ofMillis(-1);
    }
}

// spring.factories 檔案內容 (src/main/resources/META-INF/spring.factories)
// org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
// com.tutorial.config.RedisAutoConfiguration

@Configuration
public class ConditionalConfiguration {
    
    // 當類別存在時創建 Bean
    @Bean
    @ConditionalOnClass(name = "org.springframework.data.redis.core.RedisTemplate")
    public RedisService redisService() {
        return new RedisServiceImpl();
    }
    
    // 當類別不存在時創建 Bean
    @Bean
    @ConditionalOnMissingClass("org.springframework.data.redis.core.RedisTemplate")
    public CacheService memoryCacheService() {
        return new MemoryCacheService();
    }
    
    // 當 Bean 不存在時創建
    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource defaultDataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:h2:mem:defaultdb")
            .build();
    }
    
    // 當屬性存在且值匹配時創建
    @Bean
    @ConditionalOnProperty(name = "app.cache.type", havingValue = "redis")
    public CacheManager redisCacheManager() {
        return new RedisCacheManager.Builder(redisConnectionFactory()).build();
    }
    
    // 當 Web 應用程式時創建
    @Bean
    @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**").allowedOrigins("*");
            }
        };
    }
    
    // 當特定 Profile 激活時創建
    @Bean
    @Profile("development")
    public DataInitializer developmentDataInitializer() {
        return new DevelopmentDataInitializer();
    }
    
    // 複合條件
    @Bean
    @ConditionalOnProperty(name = "app.features.advanced", havingValue = "true")
    @ConditionalOnClass(AdvancedService.class)
    @ConditionalOnMissingBean(AdvancedService.class)
    public AdvancedService advancedService() {
        return new AdvancedServiceImpl();
    }
}

// 自定義健康檢查
@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    
    private final DataSource dataSource;
    
    public DatabaseHealthIndicator(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    @Override
    public Health health() {
        try (Connection connection = dataSource.getConnection()) {
            if (connection.isValid(1)) {
                return Health.up()
                    .withDetail("database", "MySQL")
                    .withDetail("validationQuery", "SELECT 1")
                    .build();
            } else {
                return Health.down()
                    .withDetail("error", "Database connection validation failed")
                    .build();
            }
        } catch (Exception e) {
            return Health.down()
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

@Component
public class ExternalServiceHealthIndicator implements HealthIndicator {
    
    private final RestTemplate restTemplate;
    
    public ExternalServiceHealthIndicator(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    @Override
    public Health health() {
        try {
            ResponseEntity<String> response = restTemplate.getForEntity(
                "https://api.external-service.com/health", String.class);
                
            if (response.getStatusCode().is2xxSuccessful()) {
                return Health.up()
                    .withDetail("externalService", "Available")
                    .withDetail("responseTime", "< 100ms")
                    .build();
            } else {
                return Health.down()
                    .withDetail("externalService", "Unavailable")
                    .withDetail("statusCode", response.getStatusCode())
                    .build();
            }
        } catch (Exception e) {
            return Health.down()
                .withDetail("externalService", "Error")
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

// 自定義指標
@Component
public class CustomMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Counter userRegistrationCounter;
    private final Timer orderProcessingTimer;
    private final Gauge activeUsersGauge;
    
    public CustomMetrics(MeterRegistry meterRegistry, UserService userService) {
        this.meterRegistry = meterRegistry;
        
        // 計數器
        this.userRegistrationCounter = Counter.builder("user.registrations")
            .description("用戶註冊數量")
            .tag("type", "new")
            .register(meterRegistry);
            
        // 計時器
        this.orderProcessingTimer = Timer.builder("order.processing.time")
            .description("訂單處理時間")
            .register(meterRegistry);
            
        // 量表
        this.activeUsersGauge = Gauge.builder("user.active.count")
            .description("活躍用戶數量")
            .register(meterRegistry, userService, UserService::getActiveUserCount);
    }
    
    public void incrementUserRegistration() {
        userRegistrationCounter.increment();
    }
    
    public void recordOrderProcessingTime(Duration duration) {
        orderProcessingTimer.record(duration);
    }
    
    public Timer.Sample startOrderProcessingTimer() {
        return Timer.start(meterRegistry);
    }
}

// 在服務中使用指標
@Service
public class OrderService {
    
    private final CustomMetrics customMetrics;
    private final OrderRepository orderRepository;
    
    public OrderService(CustomMetrics customMetrics, OrderRepository orderRepository) {
        this.customMetrics = customMetrics;
        this.orderRepository = orderRepository;
    }
    
    public Order processOrder(CreateOrderRequest request) {
        Timer.Sample sample = customMetrics.startOrderProcessingTimer();
        
        try {
            // 處理訂單邏輯
            Order order = new Order(request);
            Order savedOrder = orderRepository.save(order);
            
            // 記錄成功指標
            sample.stop(Timer.builder("order.processing.time")
                .tag("status", "success")
                .register(meterRegistry));
                
            return savedOrder;
        } catch (Exception e) {
            // 記錄失敗指標
            sample.stop(Timer.builder("order.processing.time")
                .tag("status", "error")
                .register(meterRegistry));
            throw e;
        }
    }
}

// 完整的 Spring Boot 應用程式範例
@SpringBootApplication
public class ECommerceApplication {
    
    public static void main(String[] args) {
        System.setProperty("spring.profiles.default", "development");
        SpringApplication app = new SpringApplication(ECommerceApplication.class);
        
        // 添加應用程式監聽器
        app.addListeners(new ApplicationStartupListener());
        
        // 設定額外屬性
        app.setDefaultProperties(Map.of(
            "management.endpoints.web.exposure.include", "health,info,metrics"
        ));
        
        app.run(args);
    }
    
    @Bean
    @Profile("!test")
    public CommandLineRunner dataLoader(UserService userService) {
        return args -> {
            userService.createDefaultUsers();
        };
    }
}

// 啟動監聽器
public class ApplicationStartupListener implements ApplicationListener<ApplicationReadyEvent> {
    
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        ConfigurableApplicationContext context = event.getApplicationContext();
        Environment env = context.getEnvironment();
        
        String port = env.getProperty("server.port", "8080");
        String contextPath = env.getProperty("server.servlet.context-path", "");
        String[] activeProfiles = env.getActiveProfiles();
        
        System.out.println("========================================");
        System.out.println("應用程式啟動成功！");
        System.out.println("Local: http://localhost:" + port + contextPath);
        System.out.println("Profile: " + Arrays.toString(activeProfiles));
        System.out.println("Actuator: http://localhost:" + port + contextPath + "/actuator");
        System.out.println("========================================");
    }
}

// 全局配置
@Configuration
@EnableConfigurationProperties({AppProperties.class, DatabaseProperties.class})
public class GlobalConfig {
    
    @Bean
    @Primary
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
        return mapper;
    }
    
    @Bean
    @ConditionalOnMissingBean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);
    }
}

// ✅ 推薦：建構子注入
@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    private final ValidationService validationService;
    
    // 單一建構子，Spring 會自動使用
    public UserService(UserRepository userRepository, 
                      EmailService emailService,
                      ValidationService validationService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
        this.validationService = validationService;
    }
}

// ❌ 避免：欄位注入
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository; // 難以測試
    @Autowired
    private EmailService emailService;     // 可能為 null
}

// ✅ 良好的配置類別
@Configuration
@EnableConfigurationProperties(DatabaseProperties.class)
public class DatabaseConfig {
    
    private final DatabaseProperties properties;
    
    public DatabaseConfig(DatabaseProperties properties) {
        this.properties = properties;
    }
    
    @Bean
    @Primary
    @ConditionalOnProperty(name = "database.type", havingValue = "mysql")
    public DataSource mysqlDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(properties.getUrl());
        config.setUsername(properties.getUsername());
        config.setPassword(properties.getPassword());
        config.setMaximumPoolSize(properties.getMaxPoolSize());
        config.setMinimumIdle(properties.getMinIdle());
        return new HikariDataSource(config);
    }
    
    @Bean
    @ConditionalOnMissingBean
    public TransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

// ✅ 配置屬性類別
@ConfigurationProperties(prefix = "database")
@Data
@Validated
public class DatabaseProperties {
    
    @NotBlank
    private String url;
    
    @NotBlank
    private String username;
    
    @NotBlank
    private String password;
    
    @Min(1)
    @Max(100)
    private int maxPoolSize = 20;
    
    @Min(0)
    @Max(50)
    private int minIdle = 5;
    
    @Min(1000)
    private long connectionTimeout = 30000;
}

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    
    @Mock
    private UserRepository userRepository;
    
    @Mock
    private EmailService emailService;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    @DisplayName("成功創建用戶")
    void createUser_Success() {
        // Given
        CreateUserRequest request = new CreateUserRequest();
        request.setUsername("testuser");
        request.setEmail("test@example.com");
        
        User savedUser = new User();
        savedUser.setId(1L);
        savedUser.setUsername("testuser");
        
        when(userRepository.existsByUsername("testuser")).thenReturn(false);
        when(userRepository.save(any(User.class))).thenReturn(savedUser);
        
        // When
        User result = userService.createUser(request);
        
        // Then
        assertThat(result).isNotNull();
        assertThat(result.getId()).isEqualTo(1L);
        verify(emailService).sendWelcomeEmail("test@example.com", "testuser");
    }
    
    @Test
    @DisplayName("創建用戶時用戶名已存在應拋出異常")
    void createUser_UsernameExists_ThrowsException() {
        // Given
        CreateUserRequest request = new CreateUserRequest();
        request.setUsername("existinguser");
        
        when(userRepository.existsByUsername("existinguser")).thenReturn(true);
        
        // When & Then
        assertThatThrownBy(() -> userService.createUser(request))
            .isInstanceOf(UserAlreadyExistsException.class)
            .hasMessage("用戶名 'existinguser' 已存在");
            
        verify(userRepository, never()).save(any(User.class));
        verify(emailService, never()).sendWelcomeEmail(anyString(), anyString());
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@TestPropertySource(locations = "classpath:test.properties")
@Sql(scripts = "/test-data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
@Sql(scripts = "/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
class UserControllerIntegrationTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    @DisplayName("API 創建用戶整合測試")
    void createUser_Integration_Success() {
        // Given
        CreateUserRequest request = new CreateUserRequest();
        request.setUsername("newuser");
        request.setEmail("newuser@example.com");
        request.setPassword("password123");
        
        // When
        ResponseEntity<User> response = restTemplate.postForEntity(
            "/api/users", request, User.class);
        
        // Then
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        assertThat(response.getBody()).isNotNull();
        assertThat(response.getBody().getUsername()).isEqualTo("newuser");
        
        // 驗證資料庫中確實創建了用戶
        Optional<User> savedUser = userRepository.findByUsername("newuser");
        assertThat(savedUser).isPresent();
        assertThat(savedUser.get().getEmail()).isEqualTo("newuser@example.com");
    }
    
    @Test
    @DisplayName("API 獲取用戶列表分頁測試")
    void getUsers_Pagination_Success() {
        // When
        ResponseEntity<PagedModel<User>> response = restTemplate.exchange(
            "/api/users?page=0&size=5&sort=username,asc",
            HttpMethod.GET,
            null,
            new ParameterizedTypeReference<PagedModel<User>>() {}
        );
        
        // Then
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        PagedModel<User> pagedUsers = response.getBody();
        assertThat(pagedUsers).isNotNull();
        assertThat(pagedUsers.getContent()).hasSizeLessThanOrEqualTo(5);
    }
}

// Web 層測試
@WebMvcTest(UserController.class)
class UserControllerWebTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Test
    @DisplayName("Controller 層用戶創建測試")
    void createUser_Controller_Success() throws Exception {
        // Given
        CreateUserRequest request = new CreateUserRequest();
        request.setUsername("testuser");
        request.setEmail("test@example.com");
        
        User createdUser = new User();
        createdUser.setId(1L);
        createdUser.setUsername("testuser");
        createdUser.setEmail("test@example.com");
        
        when(userService.createUser(any(CreateUserRequest.class))).thenReturn(createdUser);
        
        // When & Then
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isCreated())
            .andExpected(jsonPath("$.id").value(1L))
            .andExpected(jsonPath("$.username").value("testuser"))
            .andExpected(jsonPath("$.email").value("test@example.com"));
            
        verify(userService).createUser(any(CreateUserRequest.class));
    }
}

// Repository 層測試
@DataJpaTest
class UserRepositoryTest {
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    @DisplayName("根據用戶名查找用戶")
    void findByUsername_Exists_ReturnsUser() {
        // Given
        User user = new User();
        user.setUsername("testuser");
        user.setEmail("test@example.com");
        entityManager.persistAndFlush(user);
        
        // When
        Optional<User> found = userRepository.findByUsername("testuser");
        
        // Then
        assertThat(found).isPresent();
        assertThat(found.get().getUsername()).isEqualTo("testuser");
    }
}

### 11.3 安全性最佳實務

#### 11.3.1 輸入驗證

```java
@Data
@Validated
public class CreateUserRequest {
    
    @NotBlank(message = "用戶名不能為空")
    @Size(min = 3, max = 20, message = "用戶名長度必須在 3-20 字符之間")
    @Pattern(regexp = "^[a-zA-Z0-9_]+$", message = "用戶名只能包含字母、數字和下劃線")
    private String username;
    
    @NotBlank(message = "密碼不能為空")
    @Size(min = 8, max = 100, message = "密碼長度必須在 8-100 字符之間")
    @Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]", 
             message = "密碼必須包含大小寫字母、數字和特殊字符")
    private String password;
    
    @Email(message = "電子郵件格式無效")
    @NotBlank(message = "電子郵件不能為空")
    private String email;
    
    @Pattern(regexp = "^\\+?[1-9]\\d{1,14}$", message = "電話號碼格式無效")
    private String phoneNumber;
}

// 自定義驗證註解
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = StrongPasswordValidator.class)
public @interface StrongPassword {
    String message() default "密碼強度不足";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

@Component
public class StrongPasswordValidator implements ConstraintValidator<StrongPassword, String> {
    
    @Override
    public boolean isValid(String password, ConstraintValidatorContext context) {
        if (password == null) return false;
        
        return password.length() >= 8 &&
               password.matches(".*[a-z].*") &&
               password.matches(".*[A-Z].*") &&
               password.matches(".*\\d.*") &&
               password.matches(".*[@$!%*?&].*");
    }
}

// JWT 安全配置
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
    
    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    
    @Autowired
    private JwtRequestFilter jwtRequestFilter;
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12); // 強度 12
    }
    
    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/api/auth/**").permitAll()
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers(HttpMethod.GET, "/api/users").hasRole("USER")
                .requestMatchers(HttpMethod.POST, "/api/users").hasRole("ADMIN")
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .exceptionHandling(ex -> ex
                .authenticationEntryPoint(jwtAuthenticationEntryPoint)
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .headers(headers -> headers
                .frameOptions().deny()
                .contentTypeOptions(contentTypeOptions -> {})
                .httpStrictTransportSecurity(hstsConfig -> hstsConfig
                    .maxAgeInSeconds(31536000)
                    .includeSubdomains(true)
                )
            );
            
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
        
        return http.build();
    }
}

// 方法級安全
@Service
public class UserService {
    
    @PreAuthorize("hasRole('ADMIN') or #userId == authentication.principal.id")
    public User getUserById(Long userId) {
        return userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException("用戶不存在"));
    }
    
    @PreAuthorize("hasPermission(#user, 'WRITE')")
    public User updateUser(User user) {
        return userRepository.save(user);
    }
    
    @PostAuthorize("returnObject.owner == authentication.name or hasRole('ADMIN')")
    public Document getDocument(Long documentId) {
        return documentRepository.findById(documentId).orElse(null);
    }
}

// 安全配置屬性
@ConfigurationProperties(prefix = "app.security")
@Data
public class SecurityProperties {
    
    private Jwt jwt = new Jwt();
    private Cors cors = new Cors();
    
    @Data
    public static class Jwt {
        private String secret;
        private long expiration = 86400; // 24小時
        private String issuer = "myapp";
    }
    
    @Data
    public static class Cors {
        private String[] allowedOrigins = {"http://localhost:3000"};
        private String[] allowedMethods = {"GET", "POST", "PUT", "DELETE", "OPTIONS"};
        private String[] allowedHeaders = {"*"};
        private boolean allowCredentials = true;
        private long maxAge = 3600;
    }
}

@ConfigurationProperties(prefix = "app.datasource")
@Data
@Validated
public class DataSourceProperties {
    
    @NotBlank
    private String url;
    
    @NotBlank
    private String username;
    
    @NotBlank
    private String password;
    
    @Min(1)
    @Max(100)
    private int maximumPoolSize = 20;
    
    @Min(0)
    @Max(50)
    private int minimumIdle = 5;
    
    @Min(1000)
    private long connectionTimeout = 30000;
    
    @Min(10000)
    private long idleTimeout = 600000; // 10分鐘
    
    @Min(30000)
    private long maxLifetime = 1800000; // 30分鐘
    
    @Min(1000)
    private long leakDetectionThreshold = 60000; // 1分鐘
}

// HikariCP 配置
@Configuration
public class DataSourceConfig {
    
    @Bean
    @Primary
    @ConfigurationProperties("spring.datasource.hikari")
    public HikariDataSource dataSource(DataSourceProperties properties) {
        HikariConfig config = new HikariConfig();
        
        // 基本連接資訊
        config.setJdbcUrl(properties.getUrl());
        config.setUsername(properties.getUsername());
        config.setPassword(properties.getPassword());
        
        // 連接池配置
        config.setMaximumPoolSize(properties.getMaximumPoolSize());
        config.setMinimumIdle(properties.getMinimumIdle());
        config.setConnectionTimeout(properties.getConnectionTimeout());
        config.setIdleTimeout(properties.getIdleTimeout());
        config.setMaxLifetime(properties.getMaxLifetime());
        config.setLeakDetectionThreshold(properties.getLeakDetectionThreshold());
        
        // 連接驗證
        config.setConnectionTestQuery("SELECT 1");
        config.setValidationTimeout(5000);
        
        // 其他配置
        config.setPoolName("HikariCP-Pool");
        config.setAutoCommit(true);
        config.setConnectionInitSql("SET NAMES utf8mb4");
        
        return new HikariDataSource(config);
    }
}

// Spring Cache 配置
@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    @Primary
    public CacheManager cacheManager() {
        RedisCacheManager.Builder builder = RedisCacheManager
            .RedisCacheManagerBuilder
            .fromConnectionFactory(redisConnectionFactory())
            .cacheDefaults(cacheConfiguration());
            
        return builder.build();
    }
    
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        LettuceConnectionFactory factory = new LettuceConnectionFactory(
            new RedisStandaloneConfiguration("localhost", 6379));
        factory.setValidateConnection(true);
        return factory;
    }
    
    private RedisCacheConfiguration cacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()))
            .disableCachingNullValues();
    }
}

// 快取使用示例
@Service
public class UserService {
    
    @Cacheable(value = "users", key = "#id", condition = "#id != null")
    public User getUserById(Long id) {
        log.info("從資料庫查詢用戶: {}", id);
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("用戶不存在"));
    }
    
    @Cacheable(value = "users", key = "#username", unless = "#result == null")
    public User getUserByUsername(String username) {
        log.info("從資料庫查詢用戶: {}", username);
        return userRepository.findByUsername(username).orElse(null);
    }
    
    @CacheEvict(value = "users", key = "#user.id")
    public User updateUser(User user) {
        log.info("更新用戶並清除快取: {}", user.getId());
        return userRepository.save(user);
    }
    
    @CacheEvict(value = "users", allEntries = true)
    public void deleteUser(Long id) {
        log.info("刪除用戶並清除所有用戶快取: {}", id);
        userRepository.deleteById(id);
    }
    
    @CachePut(value = "users", key = "#result.id")
    public User createUser(CreateUserRequest request) {
        log.info("創建用戶並更新快取");
        User user = new User();
        // 設置用戶屬性
        return userRepository.save(user);
    }
}

// 自定義快取配置
@Component
public class CustomCacheConfig {
    
    @Bean
    public CacheManager customCacheManager() {
        ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
        cacheManager.setCacheNames(Arrays.asList("users", "products", "orders"));
        return cacheManager;
    }
    
    // 快取鍵生成器
    @Bean
    public KeyGenerator customKeyGenerator() {
        return (target, method, params) -> {
            StringBuilder key = new StringBuilder();
            key.append(target.getClass().getSimpleName()).append(":");
            key.append(method.getName()).append(":");
            for (Object param : params) {
                key.append(param.toString()).append(",");
            }
            return key.toString();
        };
    }
}

// 分層快取策略
@Service
public class ProductService {
    
    private final Map<String, Object> localCache = new ConcurrentHashMap<>();
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    public Product getProduct(Long id) {
        String key = "product:" + id;
        
        // L1: 本地快取
        Product product = (Product) localCache.get(key);
        if (product != null) {
            return product;
        }
        
        // L2: Redis 快取
        product = (Product) redisTemplate.opsForValue().get(key);
        if (product != null) {
            localCache.put(key, product);
            return product;
        }
        
        // L3: 資料庫
        product = productRepository.findById(id).orElse(null);
        if (product != null) {
            redisTemplate.opsForValue().set(key, product, Duration.ofMinutes(30));
            localCache.put(key, product);
        }
        
        return product;
    }
}

// 1. 依賴注入類型的比較
public class ServiceComparison {
    
    // 建構子注入 - 推薦方式
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    public ServiceComparison(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository; // 必需依賴，不可變
        this.emailService = emailService;
    }
    
    // Setter 注入 - 用於可選依賴
    private NotificationService notificationService;
    
    @Autowired(required = false)
    public void setNotificationService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }
}

@Component
public class LifecycleBean implements InitializingBean, DisposableBean {
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("@PostConstruct");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean.afterPropertiesSet()");
    }
    
    @PreDestroy
    public void preDestroy() {
        System.out.println("@PreDestroy");
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean.destroy()");
    }
}

// Singleton（預設）
@Component
@Scope("singleton")
public class SingletonBean { }

// Prototype
@Component
@Scope("prototype")
public class PrototypeBean { }

// Web 作用域
@Component
@Scope("request")
public class RequestScopedBean { }

@Component
@Scope("session")
public class SessionScopedBean { }

@Aspect
@Component
public class LoggingAspect {
    
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Before: " + joinPoint.getSignature().getName());
    }
    
    @After("execution(* com.example.service.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("After: " + joinPoint.getSignature().getName());
    }
    
    @AfterReturning(value = "execution(* com.example.service.*.*(..))", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("AfterReturning: " + result);
    }
    
    @AfterThrowing(value = "execution(* com.example.service.*.*(..))", throwing = "exception")
    public void logAfterThrowing(JoinPoint joinPoint, Exception exception) {
        System.out.println("AfterThrowing: " + exception.getMessage());
    }
    
    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println("執行時間: " + (end - start) + "ms");
        return result;
    }
}

@Controller
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping("/{id}")
    @ResponseBody
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }
    
    @PostMapping
    @ResponseBody
    public ResponseEntity<User> createUser(@RequestBody @Valid CreateUserRequest request) {
        User user = userService.create(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

@Service
@Transactional
public class TransactionService {
    
    @Transactional(propagation = Propagation.REQUIRED)
    public void required() { }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void requiresNew() { }
    
    @Transactional(propagation = Propagation.NESTED)
    public void nested() { }
    
    @Transactional(propagation = Propagation.SUPPORTS)
    public void supports() { }
    
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void notSupported() { }
    
    @Transactional(propagation = Propagation.MANDATORY)
    public void mandatory() { }
    
    @Transactional(propagation = Propagation.NEVER)
    public void never() { }
}

@Transactional(isolation = Isolation.READ_UNCOMMITTED)  // 讀未提交
@Transactional(isolation = Isolation.READ_COMMITTED)    // 讀已提交
@Transactional(isolation = Isolation.REPEATABLE_READ)   // 可重複讀
@Transactional(isolation = Isolation.SERIALIZABLE)     // 串列化

@Configuration
@ConditionalOnClass(DataSource.class)
@ConditionalOnProperty(prefix = "app.datasource", name = "enabled", havingValue = "true")
@EnableConfigurationProperties(DataSourceProperties.class)
public class CustomDataSourceAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    @Primary
    public DataSource dataSource(DataSourceProperties properties) {
        return DataSourceBuilder
            .create()
            .url(properties.getUrl())
            .username(properties.getUsername())
            .password(properties.getPassword())
            .build();
    }
}

// 整合測試
@SpringBootTest
@TestPropertySource(locations = "classpath:test.properties")
class IntegrationTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void testEndpoint() {
        ResponseEntity<String> response = restTemplate.getForEntity("/test", String.class);
        assertEquals(HttpStatus.OK, response.getStatusCode());
    }
}

// 單元測試
@ExtendWith(MockitoExtension.class)
class UnitTest {
    
    @Mock
    private Repository repository;
    
    @InjectMocks
    private Service service;
    
    @Test
    void testService() {
        when(repository.findById(1L)).thenReturn(Optional.of(new Entity()));
        Entity result = service.getById(1L);
        assertNotNull(result);
    }
}

// Web 層測試
@WebMvcTest(UserController.class)
class ControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Test
    void testGetUser() throws Exception {
        when(userService.findById(1L)).thenReturn(new User());
        
        mockMvc.perform(get("/api/users/1"))
            .andExpect(status().isOk())
            .andExpected(jsonPath("$.id").value(1));
    }
}

// ❌ 循環依賴問題
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

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

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

// ❌ 自調用不會觸發 AOP
@Service
public class UserService {
    
    @Transactional
    public void publicMethod() {
        privateMethod(); // 不會開啟事務
    }
    
    @Transactional
    private void privateMethod() {
        // 這個事務不會生效
    }
}

// ✅ 正確做法
@Service
public class UserService {
    
    @Autowired
    private UserService self; // 注入代理物件
    
    public void publicMethod() {
        self.privateMethod(); // 會觸發事務
    }
    
    @Transactional
    public void privateMethod() {
        // 事務生效
    }
}

execution(* com.example.service.*.*(..))

@Service
public class UserService {
    @Autowired
    private OrderService orderService;
}

@Service
public class OrderService {
    @Autowired
    private UserService userService;
}