# 解壓縮檔案
tar -xzf ideaIC-*.tar.gz

# 移動到 opt 目錄
sudo mv idea-IC-* /opt/intellij-idea-community

# 建立執行檔連結
sudo ln -s /opt/intellij-idea-community/bin/idea.sh /usr/local/bin/idea

# 執行 IDEA
idea

優先順序：
1. OpenJDK 17 (LTS) - 推薦用於新專案
2. OpenJDK 11 (LTS) - 適合維護既有專案
3. Oracle JDK 8 (LTS) - 適合舊版專案

下載來源：
- Adoptium (Eclipse Temurin)
- Amazon Corretto
- Oracle OpenJDK

# 設定 JAVA_HOME
[Environment]::SetEnvironmentVariable("JAVA_HOME", "C:\Program Files\Java\jdk-17", "Machine")

# 更新 PATH
$path = [Environment]::GetEnvironmentVariable("PATH", "Machine")
[Environment]::SetEnvironmentVariable("PATH", "$path;%JAVA_HOME%\bin", "Machine")

# 編輯 ~/.bashrc 或 ~/.zshrc
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk
export PATH=$JAVA_HOME/bin:$PATH

# 重新載入設定
source ~/.bashrc

<!-- ~/.m2/settings.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0">
  <localRepository>${user.home}/.m2/repository</localRepository>
  
  <mirrors>
    <mirror>
      <id>central</id>
      <mirrorOf>central</mirrorOf>
      <name>Central Repository</name>
      <url>https://repo1.maven.org/maven2</url>
    </mirror>
  </mirrors>
  
  <profiles>
    <profile>
      <id>jdk-17</id>
      <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
      </properties>
    </profile>
  </profiles>
  
  <activeProfiles>
    <activeProfile>jdk-17</activeProfile>
  </activeProfiles>
</settings>

-Dfile.encoding=UTF-8
-Dconsole.encoding=UTF-8

-Dfile.encoding=UTF-8
-Dconsole.encoding=UTF-8
-Dsun.jnu.encoding=UTF-8

Tab size: 4
Indent: 4
Continuation indent: 8
☑ Use tab character: 取消勾選（使用空格）

Right margin: 120
☑ Wrap on typing: 勾選

Class count to use import with '*': 10
Names count to use static import with '*': 5
☑ Use single class import: 勾選
Import layout:
- import static all other imports
- <blank line>
- import java.*
- import javax.*
- <blank line>
- import all other imports

<!-- Java-Code-Style.xml -->
<code_scheme name="Company Standard">
  <option name="RIGHT_MARGIN" value="120" />
  <JavaCodeStyleSettings>
    <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="10" />
    <option name="NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND" value="5" />
    <option name="IMPORT_LAYOUT_TABLE">
      <value>
        <package name="" withSubpackages="true" static="true" />
        <emptyLine />
        <package name="java" withSubpackages="true" static="false" />
        <package name="javax" withSubpackages="true" static="false" />
        <emptyLine />
        <package name="" withSubpackages="true" static="false" />
      </value>
    </option>
  </JavaCodeStyleSettings>
</code_scheme>

<!-- 常用檢查規則設定 -->
<inspections>
  <inspection class="JavaDoc" enabled="true" level="WARNING" />
  <inspection class="UnusedImport" enabled="true" level="WARNING" />
  <inspection class="MissingOverrideAnnotation" enabled="true" level="WARNING" />
  <inspection class="UnnecessaryLocalVariable" enabled="true" level="INFO" />
</inspections>

project-name/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/company/projectname/
│   │   │       └── App.java
│   │   └── resources/
│   └── test/
│       ├── java/
│       │   └── com/company/projectname/
│       │       └── AppTest.java
│       └── resources/
└── target/

# 在終端機執行
git config --global user.name "Your Name"
git config --global user.email "your.email@company.com"
git config --global init.defaultBranch main

# 常用分支操作命令
git branch                    # 檢視所有分支
git branch feature/new-api   # 建立新分支
git checkout feature/new-api # 切換分支
git checkout -b hotfix/bug   # 建立並切換分支
git branch -d feature/old    # 刪除已合併分支

<!-- 標準 Maven 生命週期 -->
validate → compile → test → package → verify → install → deploy

<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <source>17</source>
                <target>17</target>
                <encoding>UTF-8</encoding>
                <compilerArgs>
                    <arg>-Xlint:unchecked</arg>
                    <arg>-Xlint:deprecation</arg>
                </compilerArgs>
            </configuration>
        </plugin>
    </plugins>
</build>

# 記憶體設定
-Xms512m -Xmx2g

# 垃圾回收設定
-XX:+UseG1GC -XX:MaxGCPauseMillis=200

# 系統屬性
-Dspring.profiles.active=dev
-Dfile.encoding=UTF-8

# 偵錯模式
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005

<!-- pom.xml 中的 Spring Boot 插件 -->
<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>3.1.0</version>
    <configuration>
        <mainClass>com.company.Application</mainClass>
        <jvmArguments>
            -Dspring.profiles.active=dev
            -Xms256m -Xmx1g
        </jvmArguments>
    </configuration>
</plugin>

# application.yml
spring:
  profiles:
    active: dev
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver

server:
  port: 8080

logging:
  level:
    com.company: DEBUG

Name: MyApp (Local)
Main class: com.company.myapp.Application
VM options: -Dspring.profiles.active=local -Xms512m
Program arguments: --debug
Working directory: $MODULE_WORKING_DIR$

Name: Clean Install
Command line: clean install -DskipTests
Working directory: $PROJECT_DIR$

<!-- .idea/runConfigurations/Application.xml -->
<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="Application" type="Application">
    <option name="MAIN_CLASS_NAME" value="com.company.Application" />
    <option name="VM_PARAMETERS" value="-Dspring.profiles.active=dev" />
    <option name="PROGRAM_PARAMETERS" value="" />
    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
    <module name="project-name" />
  </configuration>
</component>

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<packaging>war</packaging>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

# Dockerfile
FROM openjdk:17-jre-slim

COPY target/myapp-1.0.0.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "/app.jar"]

// 範例：只在特定條件下中斷
for (int i = 0; i < 100; i++) {
    processItem(i);  // 中斷點條件：i > 50
}

-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005

<!-- pom.xml 中添加 JUnit 5 依賴 -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

@DisplayName("Calculator 測試類別")
class CalculatorTest {
    
    private Calculator calculator;
    
    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }
    
    @Test
    @DisplayName("加法測試")
    void testAdd() {
        // Given
        int a = 5;
        int b = 3;
        
        // When
        int result = calculator.add(a, b);
        
        // Then
        assertEquals(8, result, "5 + 3 應該等於 8");
    }
    
    @ParameterizedTest
    @DisplayName("參數化除法測試")
    @CsvSource({
        "10, 2, 5",
        "15, 3, 5",
        "20, 4, 5"
    })
    void testDivide(int dividend, int divisor, int expected) {
        int result = calculator.divide(dividend, divisor);
        assertEquals(expected, result);
    }
    
    @Test
    @DisplayName("除零例外測試")
    void testDivideByZero() {
        assertThrows(ArithmeticException.class, () -> {
            calculator.divide(10, 0);
        }, "除以零應該拋出 ArithmeticException");
    }
}

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.1.1</version>
    <scope>test</scope>
</dependency>

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    void testFindUserById() {
        // Given
        Long userId = 1L;
        User mockUser = new User(userId, "John Doe");
        when(userRepository.findById(userId)).thenReturn(Optional.of(mockUser));
        
        // When
        User result = userService.findById(userId);
        
        // Then
        assertThat(result.getName()).isEqualTo("John Doe");
        verify(userRepository).findById(userId);
    }
}

// 使用 Lombok 減少樣板程式碼
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Long id;
    private String name;
    private String email;
}

<!-- 在 pom.xml 中配置 -->
<plugin>
    <groupId>org.sonarsource.scanner.maven</groupId>
    <artifactId>sonar-maven-plugin</artifactId>
    <version>3.9.1.2184</version>
</plugin>

// JPA Buddy 輔助生成的 Entity
@Entity
@Table(name = "users")
@Getter
@Setter
@ToString
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private Set<Order> orders = new HashSet<>();
}

<!-- plugin.xml -->
<idea-plugin>
    <id>com.company.my-plugin</id>
    <name>My Plugin</name>
    <version>1.0</version>
    <vendor>Company</vendor>
    
    <depends>com.intellij.modules.platform</depends>
    
    <extensions defaultExtensionNs="com.intellij">
        <applicationService serviceImplementation="com.company.MyService"/>
    </extensions>
    
    <actions>
        <action id="MyAction" class="com.company.MyAction" text="My Action">
            <add-to-group group-id="ToolsMenu" anchor="first"/>
        </action>
    </actions>
</idea-plugin>

-- 查詢使用者資料
SELECT u.id, u.name, u.email, COUNT(o.id) as order_count
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
WHERE u.created_at >= '2023-01-01'
GROUP BY u.id, u.name, u.email
ORDER BY order_count DESC;

CREATE TABLE users (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    email VARCHAR(255) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    name VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    
    INDEX idx_email (email),
    INDEX idx_created_at (created_at)
);

// 自動生成的 Entity
@Entity
@Table(name = "users")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @Column(nullable = false)
    private String password;
    
    @Column(nullable = false, length = 100)
    private String name;
    
    @CreationTimestamp
    @Column(name = "created_at")
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;
}

-- 優化前
SELECT * FROM users u, orders o 
WHERE u.id = o.user_id 
AND u.created_at > '2023-01-01';

-- 優化後
SELECT u.id, u.name, o.total_amount
FROM users u
INNER JOIN orders o ON u.id = o.user_id
WHERE u.created_at > '2023-01-01'
AND u.status = 'ACTIVE'
ORDER BY o.created_at DESC
LIMIT 100;

# application-test.yml
spring:
  datasource:
    url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
    driver-class-name: org.h2.Driver
    username: sa
    password: password
  h2:
    console:
      enabled: true
      path: /h2-console
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true

@Testcontainers
@SpringBootTest
class UserRepositoryTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:14")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }
    
    @Test
    void shouldSaveAndFindUser() {
        // 測試程式碼
    }
}

-Xms2048m
-Xmx8192m
-XX:ReservedCodeCacheSize=512m
-XX:+UseConcMarkSweepGC
-XX:SoftRefLRUPolicyMSPerMB=50
-ea
-XX:CICompilerCount=2
-Dsun.io.useCanonPrefixCache=false
-Djdk.http.auth.tunneling.disabledSchemes=""
-XX:+HeapDumpOnOutOfMemoryError
-XX:-OmitStackTraceInFastThrow
-Djb.vmOptionsFile=%APPDATA%\JetBrains\IntelliJIdea2023.3\idea64.exe.vmoptions

<!-- .mvn/maven.config -->
-Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn
-Dmaven.repo.local=D:\maven-repository
-Xmx2g

# gradle.properties
org.gradle.daemon=true
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.jvmargs=-Xmx4g -XX:+HeapDumpOnOutOfMemoryError

// 加入應用程式中的效能監控
@Component
public class PerformanceMonitor {
    
    private final MeterRegistry meterRegistry;
    
    @EventListener
    public void handleMethodExecution(MethodExecutionEvent event) {
        Timer.Sample sample = Timer.start(meterRegistry);
        try {
            // 方法執行
        } finally {
            sample.stop(Timer.builder("method.execution")
                         .tag("class", event.getClassName())
                         .tag("method", event.getMethodName())
                         .register(meterRegistry));
        }
    }
}

# 錯誤訊息
java.lang.OutOfMemoryError: Java heap space

# 解決方案
- 增加 heap 大小：-Xmx8g
- 檢查記憶體洩漏
- 使用更高效的 GC：-XX:+UseG1GC

# 排查步驟
1. 安全模式啟動：Help → Diagnostic Tools → Start IDE in Safe Mode
2. 逐步啟用插件確認問題插件
3. 檢查插件版本相容性

# 解決步驟
1. File → Invalidate Caches and Restart
2. 檢查專案 SDK 設定
3. 重新匯入 Maven/Gradle 專案

<!-- Maven 代理設定 -->
<proxies>
    <proxy>
        <id>company-proxy</id>
        <active>true</active>
        <protocol>http</protocol>
        <host>proxy.company.com</host>
        <port>8080</port>
        <username>user</username>
        <password>password</password>
    </proxy>
</proxies>

<!-- .editorconfig 檔案 -->
root = true

[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true

[*.java]
indent_style = space
indent_size = 4
max_line_length = 120

[*.{xml,yml,yaml}]
indent_style = space
indent_size = 2

<!-- pom.xml 中添加 CheckStyle 插件 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-checkstyle-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
        <configLocation>checkstyle.xml</configLocation>
        <encoding>UTF-8</encoding>
        <consoleOutput>true</consoleOutput>
        <failsOnError>true</failsOnError>
    </configuration>
    <executions>
        <execution>
            <id>validate</id>
            <phase>validate</phase>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
</plugin>

/**
 * 使用者服務類別，提供使用者相關的業務邏輯處理。
 * 
 * <p>此類別負責處理使用者的 CRUD 操作，包括：
 * <ul>
 *   <li>使用者註冊和登入驗證</li>
 *   <li>使用者資料查詢和更新</li>
 *   <li>使用者權限管理</li>
 * </ul>
 * 
 * @author John Doe
 * @version 1.0
 * @since 2023-01-01
 */
@Service
public class UserService {
    
    /**
     * 根據使用者 ID 查詢使用者資訊。
     * 
     * @param userId 使用者唯一識別碼，不可為 null
     * @return 使用者資訊物件，如果找不到則拋出例外
     * @throws UserNotFoundException 當指定 ID 的使用者不存在時
     * @throws IllegalArgumentException 當 userId 為 null 時
     * @see User
     * @since 1.0
     */
    public User findById(@NonNull Long userId) {
        if (userId == null) {
            throw new IllegalArgumentException("User ID cannot be null");
        }
        
        return userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException("User not found: " + userId));
    }
}

// ✅ 好的註解：說明為什麼，而不是做什麼
/**
 * 使用 BCrypt 演算法加密密碼，提供安全的密碼儲存。
 * 使用 salt round 為 12，在安全性和效能間取得平衡。
 */
public String encryptPassword(String plainPassword) {
    return BCrypt.hashpw(plainPassword, BCrypt.gensalt(12));
}

// ❌ 不好的註解：只是重複程式碼
/**
 * 加密密碼
 */
public String encryptPassword(String plainPassword) {
    return BCrypt.hashpw(plainPassword, BCrypt.gensalt(12));
}

<properties>
    <!-- 統一管理版本號 -->
    <spring.boot.version>3.1.0</spring.boot.version>
    <junit.version>5.9.2</junit.version>
    <mockito.version>5.1.1</mockito.version>
</properties>

<dependencyManagement>
    <dependencies>
        <!-- 使用 BOM 管理版本 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring.boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- 生產依賴 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- 測試依賴 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<!-- OWASP Dependency Check 插件 -->
<plugin>
    <groupId>org.owasp</groupId>
    <artifactId>dependency-check-maven</artifactId>
    <version>8.2.1</version>
    <executions>
        <execution>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
</plugin>

# application.yml (基本設定)
spring:
  application:
    name: myapp
  profiles:
    active: @spring.profiles.active@

server:
  servlet:
    context-path: /api

logging:
  pattern:
    console: "%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"

---
# application-dev.yml (開發環境)
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:h2:mem:devdb
    username: sa
    password: password
  jpa:
    show-sql: true

---
# application-prod.yml (生產環境)
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:postgresql://prod-db:5432/myapp
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  jpa:
    show-sql: false

# 使用環境變數
database.password=${DB_PASSWORD:defaultPassword}
jwt.secret=${JWT_SECRET:defaultSecret}
api.key=${EXTERNAL_API_KEY:}

# 使用 Spring Boot 的配置處理器
@ConfigurationProperties(prefix = "app.security")
@Configuration
public class SecurityProperties {
    private String jwtSecret;
    private Duration jwtExpiration = Duration.ofHours(24);
    
    // getters and setters
}

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    @ExceptionHandler(UserNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ErrorResponse handleUserNotFound(UserNotFoundException ex) {
        logger.warn("User not found: {}", ex.getMessage());
        return new ErrorResponse("USER_NOT_FOUND", ex.getMessage());
    }
    
    @ExceptionHandler(IllegalArgumentException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ErrorResponse handleIllegalArgument(IllegalArgumentException ex) {
        logger.warn("Invalid argument: {}", ex.getMessage());
        return new ErrorResponse("INVALID_ARGUMENT", ex.getMessage());
    }
    
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ErrorResponse handleGeneral(Exception ex) {
        logger.error("Unexpected error", ex);
        return new ErrorResponse("INTERNAL_ERROR", "An unexpected error occurred");
    }
}

@Service
public class UserService {
    
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    
    public User createUser(CreateUserRequest request) {
        logger.info("Creating user with email: {}", request.getEmail());
        
        try {
            User user = userMapper.toEntity(request);
            User savedUser = userRepository.save(user);
            
            logger.info("User created successfully with ID: {}", savedUser.getId());
            return savedUser;
            
        } catch (DataIntegrityViolationException ex) {
            logger.error("Failed to create user due to data integrity violation: {}", 
                         ex.getMessage());
            throw new UserAlreadyExistsException("User with this email already exists");
        }
    }
}

// 單元測試 (70%)
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    @Mock private UserRepository userRepository;
    @InjectMocks private UserService userService;
    
    @Test
    void shouldCreateUserSuccessfully() {
        // 測試業務邏輯
    }
}

// 整合測試 (20%)
@SpringBootTest
@Testcontainers
class UserRepositoryTest {
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:14");
    
    @Test
    void shouldPersistUserCorrectly() {
        // 測試資料層整合
    }
}

// 端到端測試 (10%)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserControllerE2ETest {
    @Autowired private TestRestTemplate restTemplate;
    
    @Test
    void shouldCreateUserViaAPI() {
        // 測試完整 API 流程
    }
}

@TestConfiguration
public class TestDataConfig {
    
    @Bean
    @Primary
    public UserRepository testUserRepository() {
        return new InMemoryUserRepository();
    }
    
    @EventListener
    public void resetTestData(TestExecutionEvent event) {
        if (event.getTestContext().getTestMethod().isAnnotationPresent(ResetData.class)) {
            // 重置測試資料
        }
    }
}

# application.yml
spring:
  jpa:
    hibernate:
      ddl-auto: none  # 生產環境不自動建立表格
  main:
    lazy-initialization: true  # 延遲初始化
  datasource:
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5

@Component
public class MemoryMonitor {
    
    private static final Logger logger = LoggerFactory.getLogger(MemoryMonitor.class);
    
    @Scheduled(fixedRate = 60000)  // 每分鐘檢查一次
    public void logMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        long totalMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        long usedMemory = totalMemory - freeMemory;
        
        logger.info("Memory usage - Used: {} MB, Free: {} MB, Total: {} MB",
                   usedMemory / (1024 * 1024),
                   freeMemory / (1024 * 1024),
                   totalMemory / (1024 * 1024));
    }
}

@RestController
public class UserController {
    
    @PostMapping("/users")
    public ResponseEntity<User> createUser(@Valid @RequestBody CreateUserRequest request) {
        // Spring Validation 自動驗證
        User user = userService.createUser(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

// DTO 驗證
public class CreateUserRequest {
    
    @NotBlank(message = "Email is required")
    @Email(message = "Invalid email format")
    private String email;
    
    @NotBlank(message = "Password is required")
    @Size(min = 8, message = "Password must be at least 8 characters")
    @Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).*$", 
             message = "Password must contain uppercase, lowercase and digit")
    private String password;
    
    // getters and setters
}

# 檢查 JAVA_HOME 設定
echo $JAVA_HOME  # macOS/Linux
echo %JAVA_HOME% # Windows

# 檢查 Java 版本
java -version
javac -version