安裝環境 → 建立第一個 Spring Boot 專案 → 學習 Copilot 基本操作
→ 開發 REST API → 連接資料庫 → 加入安全性 → 測試與除錯 → 部署

# 使用 winget 安裝 Java 21
winget install Microsoft.OpenJDK.21

# 驗證安裝
java -version
javac -version

# 使用 Homebrew 安裝
brew install --cask temurin@21

# 驗證安裝
java -version

sudo apt update
sudo apt install temurin-21-jdk

# 設定 JAVA_HOME
echo 'export JAVA_HOME=/usr/lib/jvm/temurin-21' >> ~/.bashrc
source ~/.bashrc

套件 ID：vscjava.vscode-java-pack

套件 ID：vmware.vscode-spring-boot
套件 ID：vscjava.vscode-spring-initializr
套件 ID：vscjava.vscode-spring-boot-dashboard

套件 ID：GitHub.copilot
套件 ID：GitHub.copilot-chat

// 計算費氏數列第 n 項
public int fibonacci(

{
  "java.jdt.ls.java.home": "/path/to/jdk-21",
  "java.compile.nullAnalysis.mode": "automatic",
  "editor.suggestSelection": "first",
  "editor.inlineSuggest.enabled": true,
  "github.copilot.enable": {
    "*": true,
    "yaml": true,
    "plaintext": false,
    "markdown": true
  },
  "github.copilot.editor.enableAutoCompletions": true,
  "spring-boot.ls.java.home": "/path/to/jdk-21",
  "editor.formatOnSave": true,
  "java.format.settings.profile": "GoogleStyle",
  "[java]": {
    "editor.defaultFormatter": "redhat.java"
  }
}

幫我建立一個 Spring Boot 3 的 Maven 專案結構，
包含 Controller、Service、Repository 三層架構，
使用 MySQL 資料庫，並加入 Lombok 和 Spring Security

demo-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demoapp/
│   │   │       ├── DemoAppApplication.java   ← 啟動入口
│   │   │       ├── controller/               ← REST API 層
│   │   │       ├── service/                  ← 業務邏輯層
│   │   │       ├── repository/               ← 資料存取層
│   │   │       ├── model/                    ← Entity 實體
│   │   │       ├── dto/                      ← 資料傳輸物件
│   │   │       ├── config/                   ← 設定類別
│   │   │       └── exception/                ← 例外處理
│   │   └── resources/
│   │       ├── application.yml               ← 主要設定
│   │       ├── application-dev.yml           ← 開發環境設定
│   │       └── static/                       ← 靜態資源
│   └── test/
│       └── java/                             ← 測試程式碼
├── pom.xml                                   ← Maven 設定
└── .gitignore

// 建立一個 UserService，實作 CRUD 操作，使用 UserRepository
// 方法需要處理使用者不存在的情況並拋出自定義例外
public class UserService {
    // Copilot 將在此處根據上方註解自動補全

@workspace 我們的專案中，如何實作分頁查詢？
@terminal 這個 Maven 錯誤怎麼解決？
#file:UserController.java 這個 Controller 缺少哪些安全性設定？

請在以下檔案中加入使用者認證功能：
- UserController.java
- UserService.java
- SecurityConfig.java

要求：使用 JWT Token，並在 Controller 加入 @PreAuthorize 注解

public List<User> findAll() {
    // [Ctrl+I] 加入快取機制，使用 Spring Cache，TTL 設為 5 分鐘
}

spring:
  application:
    name: demo-app
  datasource:
    url: jdbc:mysql://localhost:3306/demo_db?useSSL=false&serverTimezone=UTC
    username: ${DB_USERNAME:root}
    password: ${DB_PASSWORD:secret}
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQLDialect
        format_sql: true

server:
  port: 8080

logging:
  level:
    com.example: DEBUG

package com.example.demoapp.model;

import jakarta.persistence.*;
import lombok.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true, length = 50)
    private String username;

    @Column(nullable = false)
    private String password;

    @Column(nullable = false, unique = true)
    private String email;

    @Enumerated(EnumType.STRING)
    private Role role;

    @Column(name = "created_at", updatable = false)
    private LocalDateTime createdAt;

    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
        updatedAt = LocalDateTime.now();
    }

    @PreUpdate
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }

    public enum Role {
        ADMIN, USER, MODERATOR
    }
}

package com.example.demoapp.controller;

import com.example.demoapp.dto.UserDTO;
import com.example.demoapp.service.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/v1/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;

    // 取得所有使用者（分頁）
    @GetMapping
    @PreAuthorize("hasRole('ADMIN')")
    public ResponseEntity<Page<UserDTO>> getAllUsers(Pageable pageable) {
        return ResponseEntity.ok(userService.findAll(pageable));
    }

    // 取得單一使用者
    @GetMapping("/{id}")
    public ResponseEntity<UserDTO> getUserById(@PathVariable Long id) {
        return ResponseEntity.ok(userService.findById(id));
    }

    // 建立使用者
    @PostMapping
    public ResponseEntity<UserDTO> createUser(@Valid @RequestBody UserDTO dto) {
        return ResponseEntity.status(HttpStatus.CREATED)
                .body(userService.create(dto));
    }

    // 更新使用者
    @PutMapping("/{id}")
    public ResponseEntity<UserDTO> updateUser(
            @PathVariable Long id,
            @Valid @RequestBody UserDTO dto) {
        return ResponseEntity.ok(userService.update(id, dto));
    }

    // 刪除使用者
    @DeleteMapping("/{id}")
    @PreAuthorize("hasRole('ADMIN')")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

package com.example.demoapp.repository;

import com.example.demoapp.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.Optional;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByUsername(String username);
    Optional<User> findByEmail(String email);
    boolean existsByUsername(String username);
    boolean existsByEmail(String email);

    @Query("SELECT u FROM User u WHERE u.role = :role")
    java.util.List<User> findAllByRole(User.Role role);
}

// UserService.java（介面）
public interface UserService {
    Page<UserDTO> findAll(Pageable pageable);
    UserDTO findById(Long id);
    UserDTO create(UserDTO dto);
    UserDTO update(Long id, UserDTO dto);
    void delete(Long id);
}

// UserServiceImpl.java（實作）
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class UserServiceImpl implements UserService {

    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final UserMapper userMapper;

    @Override
    public Page<UserDTO> findAll(Pageable pageable) {
        return userRepository.findAll(pageable)
                .map(userMapper::toDTO);
    }

    @Override
    public UserDTO findById(Long id) {
        return userRepository.findById(id)
                .map(userMapper::toDTO)
                .orElseThrow(() -> new ResourceNotFoundException("User not found: " + id));
    }

    @Override
    @Transactional
    public UserDTO create(UserDTO dto) {
        if (userRepository.existsByUsername(dto.getUsername())) {
            throw new DuplicateResourceException("Username already exists");
        }
        User user = userMapper.toEntity(dto);
        user.setPassword(passwordEncoder.encode(dto.getPassword()));
        return userMapper.toDTO(userRepository.save(user));
    }
    // ... 其他方法
}

# docker-compose.yml
version: '3.8'
services:
  mysql:
    image: mysql:8.0
    container_name: demo-mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: demo_db
      MYSQL_USER: demouser
      MYSQL_PASSWORD: demopass
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql

volumes:
  mysql_data:

# 啟動資料庫
docker-compose up -d mysql

# 確認狀態
docker-compose ps

<!-- pom.xml 加入 -->
<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-mysql</artifactId>
</dependency>

-- src/main/resources/db/migration/V1__create_users_table.sql
CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    role ENUM('ADMIN', 'USER', 'MODERATOR') NOT NULL DEFAULT 'USER',
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    INDEX idx_username (username),
    INDEX idx_email (email)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

package com.example.demoapp.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/v1/auth/**").permitAll()
                .requestMatchers("/actuator/health").permitAll()
                .anyRequest().authenticated()
            )
            // 加入 JWT Filter（使用 Copilot 生成）
            // .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class)
            .build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);
    }
}

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "java",
      "name": "Debug Spring Boot App",
      "request": "launch",
      "mainClass": "com.example.demoapp.DemoAppApplication",
      "projectName": "demo-app",
      "env": {
        "SPRING_PROFILES_ACTIVE": "dev",
        "DB_USERNAME": "demouser",
        "DB_PASSWORD": "demopass"
      },
      "vmArgs": "-Xmx512m"
    },
    {
      "type": "java",
      "name": "Attach to Remote (8000)",
      "request": "attach",
      "hostName": "localhost",
      "port": 8000
    }
  ]
}

為 UserServiceImpl.create() 方法生成完整的 JUnit 5 單元測試，
使用 Mockito 模擬 UserRepository，
覆蓋正常流程和例外情況（帳號重複、驗證失敗等）

@ExtendWith(MockitoExtension.class)
class UserServiceImplTest {

    @Mock
    private UserRepository userRepository;

    @Mock
    private PasswordEncoder passwordEncoder;

    @InjectMocks
    private UserServiceImpl userService;

    @Test
    @DisplayName("建立使用者 - 成功情境")
    void createUser_Success() {
        // Given
        UserDTO dto = UserDTO.builder()
            .username("testuser")
            .email("test@example.com")
            .password("password123")
            .build();

        when(userRepository.existsByUsername("testuser")).thenReturn(false);
        when(passwordEncoder.encode(anyString())).thenReturn("encoded_password");
        when(userRepository.save(any(User.class))).thenAnswer(i -> i.getArgument(0));

        // When
        UserDTO result = userService.create(dto);

        // Then
        assertNotNull(result);
        assertEquals("testuser", result.getUsername());
        verify(userRepository).save(any(User.class));
    }

    @Test
    @DisplayName("建立使用者 - 帳號重複應拋出例外")
    void createUser_DuplicateUsername_ThrowsException() {
        // Given
        when(userRepository.existsByUsername(anyString())).thenReturn(true);

        // When & Then
        assertThrows(DuplicateResourceException.class,
            () -> userService.create(new UserDTO()));
    }
}

### 取得所有使用者
GET http://localhost:8080/api/v1/users
Authorization: Bearer {{token}}
Content-Type: application/json

###
### 建立使用者
POST http://localhost:8080/api/v1/users
Content-Type: application/json

{
  "username": "johndoe",
  "email": "john@example.com",
  "password": "SecurePass123!",
  "role": "USER"
}

###
### 登入取得 Token
POST http://localhost:8080/api/v1/auth/login
Content-Type: application/json

{
  "username": "admin",
  "password": "adminpass"
}

# Maven
./mvnw versions:display-dependency-updates

# Gradle
./gradlew dependencyUpdates

# 使用 Maven Wrapper 升級
./mvnw spring-boot:help -Ddetail=true -Dgoal=help

# 修改 pom.xml 中的版本
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.5</version>  <!-- 更新此版本號 -->
</parent>

# VS Code 自動更新
檔案 → 喜好設定 → 設定 → 搜尋 "update mode"
建議設定：default（自動下載，重啟後安裝）

# 手動更新擴充套件
Ctrl+Shift+X → 點擊擴充套件面板右上方 "..." → 更新所有擴充套件

// 類別：大駝峰式
public class UserAccountService { }

// 方法/變數：小駝峰式
private String userAccountName;
public void getUserAccount() { }

// 常數：全大寫底線
private static final int MAX_RETRY_COUNT = 3;

// 套件：全小寫
package com.example.demoapp.service;

feat: 新增使用者分頁查詢功能
fix: 修復 JWT Token 過期驗證問題
refactor: 重構 UserService 提升效能
test: 新增 UserController 整合測試
docs: 更新 API 文件
chore: 升級 Spring Boot 至 3.3.5

# Copilot 專案指引

## 程式語言與框架
- Java 21, Spring Boot 3.3, Maven

## 編碼規範
- 使用 Lombok 減少樣板程式碼
- 所有 Service 方法加 @Transactional
- 例外處理使用自定義 Exception 類別

## 命名規範
- Entity 類別對應表名（UserProfile → user_profiles）
- DTO 使用 record 或 Lombok @Data

## 禁止事項
- 不使用 System.out.println，改用 SLF4J Logger
- 不在 Controller 直接操作 Entity，需透過 DTO

// settings.json 手動指定 JDK 路徑
{
  "java.jdt.ls.java.home": "C:\\Program Files\\Eclipse Adoptium\\jdk-21.0.4.7-hotspot",
  // macOS: "/Library/Java/JavaVirtualMachines/temurin-21.jdk/Contents/Home"
  // Linux: "/usr/lib/jvm/temurin-21"
}

# 確認 Docker MySQL 正在執行
docker-compose ps

# 確認連線設定
curl http://localhost:3306 # 應顯示連線被拒（代表 MySQL 有在監聽）

# 查看 Spring Boot 日誌
# VS Code Terminal 中執行：
./mvnw spring-boot:run -Dspring-boot.run.profiles=dev

{
  "github.copilot.chat.codeGeneration.useInstructionFiles": true
}

# 生成 REST Controller
幫我建立一個 [ProductController]，包含 CRUD 操作的 REST API，
使用 [ProductService]，回傳 [ProductDTO]，
加入適當的 HTTP 狀態碼和 @Valid 驗證，
URL 前綴為 /api/v1/products

# 生成 JPA Entity
建立一個 [Order] Entity，欄位包含：id、訂單編號、使用者ID、總金額、狀態（Enum）、建立時間，
使用 Lombok，加入適當的 JPA 注解和索引

# 生成 Service 實作
幫我實作 [UserService] 介面，使用 [UserRepository]，
包含分頁查詢、根據 Email 查詢、軟刪除功能，
使用 MapStruct 做 DTO 轉換，並處理適當的例外情況

# 分析效能問題
以下程式碼在高並發下有效能問題，請分析原因並提供改善方案：
[貼上程式碼]

# 解釋複雜程式碼
請用繁體中文解釋以下程式碼的運作原理，並說明可能的改善點：
[貼上程式碼]

# 修復錯誤
以下程式碼出現錯誤：[錯誤訊息]，請協助修復並解釋原因：
[貼上程式碼]

# 生成完整測試
為以下 Service 方法生成 JUnit 5 + Mockito 單元測試，
覆蓋：正常情境、邊界條件、例外情境，
測試方法命名使用 [方法名]_[條件]_[預期結果] 格式：
[貼上程式碼]

# 生成整合測試
使用 @SpringBootTest 和 TestContainers 為 [UserRepository] 
生成整合測試，測試 CRUD 操作

# 架構建議
我正在設計一個電商系統，需要處理高並發訂單，
請建議使用 Spring Boot 的最佳架構設計，
包含：快取策略、非同步處理、資料庫設計建議

# 重構建議
以下程式碼違反了 SOLID 原則，請分析違反了哪些原則，
並提供重構建議和範例程式碼：
[貼上程式碼]

# 安全性審查
請審查以下 Spring Security 設定，
指出潛在的安全性問題並提供修復方案：
[貼上程式碼]