Forem: Cyrus Tse

Spring Boot 4 入門教學 - Part 8 (常見問題與排錯)

Cyrus Tse — Sun, 25 Jan 2026 07:01:54 +0000

第八章：常見問題與排錯

8.1 連接資料庫常見問題

問題一：連接被拒絕

錯誤訊息：Connection to localhost:5432 refused.

解決方案：

檢查 PostgreSQL 服務是否正在運行
檢查連接埠是否正確（預設 5432）
檢查防火牆是否阻止了連接
檢查 pg_hba.conf 是否允許遠程連接

# 檢查 PostgreSQL 服務狀態（Linux）
sudo systemctl status postgresql

# 檢查 PostgreSQL 服務狀態（macOS）
brew services list | grep postgresql

問題二：認證失敗

錯誤訊息：password authentication failed for user

解決方案：

檢查用戶名和密碼是否正確
檢查 pg_hba.conf 中的認證方式
確保用戶具有登入權限

問題三：資料庫不存在

錯誤訊息：database "myapp_db" does not exist

解決方案：

-- 創建資料庫
CREATE DATABASE myapp_db;

-- 授權給用戶
GRANT ALL PRIVILEGES ON DATABASE myapp_db TO myapp_user;

8.2 Spring Boot 啟動問題

問題一：埠口被佔用

錯誤訊息：Port 8080 was already in use

解決方案：

找出佔用埠口的程序並終止
或在 application.properties 中更改埠口

# 找出佔用 8080 埠口的程序
lsof -i :8080

# 殺死程序
kill -9 <PID>

# 或更改埠口
# server.port=8081

問題二：依賴無法解析

解決方案：

重新整理 Maven/Gradle 依賴
清理本地緩存

# Maven
./mvnw dependency:resolve
./mvnw clean install -U

# Gradle
./gradlew dependencies
./gradlew clean build --refresh-dependencies

8.3 JdbcTemplate 問題

問題一：無參數化查詢導致 SQL 注入

危險的程式碼：

// 千萬不要這樣做！
String sql = "SELECT * FROM users WHERE username = '" + username + "'";
jdbcTemplate.queryForObject(sql, ...);

安全的做法：

// 使用參數化查詢
String sql = "SELECT * FROM users WHERE username = ?";
jdbcTemplate.queryForObject(sql, new Object[]{username}, ...);

問題二：ResultSet 映射錯誤

確保資料庫欄位名稱與 Java 屬性名稱匹配，或者使用自定義的 RowMapper。

// 自定義 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.setUsername(rs.getString("username"));
        user.setEmail(rs.getString("email"));
        // 手動映射每個欄位
        return user;
    }
}

8.4 學習資源推薦

官方文檔：

Spring Boot 官方文檔：https://docs.spring.io/spring-boot/docs/current/reference/html/
Spring Framework 文檔：https://docs.spring.io/spring-framework/reference/
PostgreSQL 文檔：https://www.postgresql.org/docs/

書籍推薦：

《Spring Boot in Action》
《Spring 實戰》

線上課程：

Spring 官方教程
Baeldung Spring 教程

結語

恭喜你完成了這個完整的 Spring Boot 4 入門教學！我們涵蓋了：

Spring Boot 4 與 3 的差異：Java 版本需求、Jakarta EE 遷移、Spring Security 變化
建立第一個專案：Spring Initializr、專案結構、運行應用程式
核心概念：@SpringBootApplication、@bean、IoC/DI
REST API 開發：@RestController、@GetMapping、CRUD 操作
資料庫連接：PostgreSQL 配置、JdbcTemplate 使用
完整專案實作：整合所有知識的 CRUD 專案

建議的後續學習路徑：

學習 Spring Data JPA 簡化資料庫操作
學習 Spring Security 實現用戶認證
學習 Spring Boot Actuator 監控應用程式
學習 Docker 容器化部署
學習雲原生開發

祝你學習順利，程式碼無 bug！

Spring Boot 4 入門教學 - Part 7 (完整 CRUD 專案實作)

Cyrus Tse — Sun, 25 Jan 2026 07:01:31 +0000

第七章：完整的 CRUD 專案實作

7.1 專案結構總覽

在這一章節中，我們將整合前幾章學習的所有知識，創建一個完整的 Spring Boot CRUD 專案。這個專案將包含：

User 實體（對應資料庫表）
Repository 層（資料存取）
Service 層（業務邏輯）
Controller 層（REST API）
DTO 類（資料傳輸對象）
異常處理
統一響應格式

專案結構如下：

src/main/java/com/example/myfirstapp/
├── MyFirstAppApplication.java          # 主應用程式類
├── config/
│   ├── AppConfig.java                  # 應用配置
│   ├── GlobalExceptionHandler.java     # 全局異常處理
│   └── ResourceNotFoundException.java  # 自定義異常
├── controller/
│   └── UserController.java             # REST 控制器
├── dto/
│   ├── ApiResponse.java                # 統一響應格式
│   ├── CreateUserRequest.java          # 創建用戶請求
│   └── UserResponse.java               # 用戶響應
├── entity/
│   └── User.java                       # 用戶實體
├── repository/
│   └── UserRepository.java             # 資料存取層
└── service/
    └── UserService.java                # 業務邏輯層

src/main/resources/
├── application.properties              # 應用配置
└── application.yml                     # 應用配置（YAML格式）

7.2 完整的程式碼清單

以下是完整的專案程式碼，你可以直接複製使用。

主應用程式類：

package com.example.myfirstapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

User 實體類：

package com.example.myfirstapp.entity;

import java.time.LocalDateTime;

public class User {
    private Long id;
    private String username;
    private String email;
    private String password;
    private String fullName;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    private Boolean active;

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getFullName() { return fullName; }
    public void setFullName(String fullName) { this.fullName = fullName; }
    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
    public LocalDateTime getUpdatedAt() { return updatedAt; }
    public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
    public Boolean isActive() { return active; }
    public void setActive(Boolean active) { this.active = active; }
}

Repository 類：

package com.example.myfirstapp.repository;

import com.example.myfirstapp.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public class UserRepository {

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public UserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public List<User> findAll() {
        String sql = "SELECT id, username, email, password, full_name, " +
                     "created_at, updated_at, active FROM users ORDER BY id";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
    }

    public Optional<User> findById(Long id) {
        String sql = "SELECT id, username, email, password, full_name, " +
                     "created_at, updated_at, active FROM users WHERE id = ?";
        try {
            User user = jdbcTemplate.queryForObject(sql,
                new BeanPropertyRowMapper<>(User.class), id);
            return Optional.ofNullable(user);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    public User save(User user) {
        if (user.getId() == null) {
            String sql = "INSERT INTO users (username, email, password, full_name, " +
                         "created_at, updated_at, active) VALUES (?, ?, ?, ?, ?, ?, ?)";
            java.time.LocalDateTime now = java.time.LocalDateTime.now();
            jdbcTemplate.update(sql,
                user.getUsername(), user.getEmail(), user.getPassword(),
                user.getFullName(), now, now,
                user.isActive() != null ? user.isActive() : true);

            String currSql = "SELECT currval(pg_get_serial_sequence('users', 'id'))";
            Long id = jdbcTemplate.queryForObject(currSql, Long.class);
            user.setId(id);
            user.setCreatedAt(now);
            user.setUpdatedAt(now);
        } else {
            String sql = "UPDATE users SET username = ?, email = ?, password = ?, " +
                         "full_name = ?, updated_at = ?, active = ? WHERE id = ?";
            jdbcTemplate.update(sql,
                user.getUsername(), user.getEmail(), user.getPassword(),
                user.getFullName(), java.time.LocalDateTime.now(),
                user.isActive(), user.getId());
            user.setUpdatedAt(java.time.LocalDateTime.now());
        }
        return user;
    }

    public void deleteById(Long id) {
        String sql = "DELETE FROM users WHERE id = ?";
        jdbcTemplate.update(sql, id);
    }

    public boolean existsByUsername(String username) {
        String sql = "SELECT COUNT(*) FROM users WHERE username = ?";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class, username);
        return count != null && count > 0;
    }

    public boolean existsByEmail(String email) {
        String sql = "SELECT COUNT(*) FROM users WHERE email = ?";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class, email);
        return count != null && count > 0;
    }
}

Service 類：

package com.example.myfirstapp.service;

import com.example.myfirstapp.config.ResourceNotFoundException;
import com.example.myfirstapp.entity.User;
import com.example.myfirstapp.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("User", id));
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public void deleteById(Long id) {
        if (!userRepository.findById(id).isPresent()) {
            throw new ResourceNotFoundException("User", id);
        }
        userRepository.deleteById(id);
    }

    public boolean existsByUsername(String username) {
        return userRepository.existsByUsername(username);
    }

    public boolean existsByEmail(String email) {
        return userRepository.existsByEmail(email);
    }
}

Spring Boot 4 入門教學 - Part 6 (JDBC 資料庫連接)

Cyrus Tse — Sun, 25 Jan 2026 07:01:10 +0000

第六章：JDBC 資料庫連接

6.1 前言：資料庫連接的基礎

在這一章節中，我們將學習如何使用 Spring Boot 連接到 PostgreSQL 資料庫，並執行基本的資料庫操作。資料庫連接是大多數 Web 應用程式的核心功能之一，Spring Boot 提供了多種方式來簡化這個過程。

我們將使用 Spring 的 JdbcTemplate 來進行資料庫操作，這是一個輕量級且靈活的工具，適合學習和理解 JDBC 的運作原理。

6.2 添加 PostgreSQL 依賴

首先，我們需要在 pom.xml 中添加 PostgreSQL 驅動依賴。如果你使用 Spring Initializr 時已經添加了「PostgreSQL Driver」，則不需要手動添加。

<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot Starter JDBC -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- PostgreSQL Driver -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- 其他依賴 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

6.3 配置資料來源

在 application.properties 中配置 PostgreSQL 連接：

# src/main/resources/application.properties

# PostgreSQL 資料庫連接配置
spring.datasource.url=jdbc:postgresql://localhost:5432/myapp_db
spring.datasource.username=myapp_user
spring.datasource.password=your_password
spring.datasource.driver-class-name=org.postgresql.Driver

# 連接池配置（HikariCP）
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000

# JPA/Hibernate 配置（如果你使用 JPA）
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

# 伺服器端口
server.port=8080

# 日誌配置
logging.level.com.zaxxer.hikari=INFO
logging.level.org.springframework.jdbc=DEBUG

或者使用 application.yml 格式：

# src/main/resources/application.yml

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/myapp_db
    username: myapp_user
    password: your_password
    driver-class-name: org.postgresql.Driver
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        dialect: org.hibernate.dialect.PostgreSQLDialect

server:
  port: 8080

logging:
  level:
    com.zaxxer.hikari: INFO
    org.springframework.jdbc: DEBUG

6.4 創建資料表

登入 PostgreSQL 並創建用戶表：

-- 登入 PostgreSQL
psql -U myapp_user -d myapp_db

-- 創建 users 表
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    full_name VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    active BOOLEAN DEFAULT TRUE
);

-- 創建索引
CREATE INDEX idx_users_username ON users(username);
CREATE INDEX idx_users_email ON users(email);

-- 插入測試數據
INSERT INTO users (username, email, password, full_name, active) VALUES
('john', 'john@example.com', 'password123', 'John Doe', TRUE),
('jane', 'jane@example.com', 'password456', 'Jane Smith', TRUE),
('bob', 'bob@example.com', 'password789', 'Bob Johnson', FALSE);

-- 查詢數據
SELECT * FROM users;

6.5 使用 JdbcTemplate 操作資料庫

讓我們創建一個完整的 User 實體和 Repository 類：

package com.example.myfirstapp.entity;

import java.time.LocalDateTime;

/**
 * User 實體類
 * 對應資料庫中的 users 表
 */
public class User {

    private Long id;
    private String username;
    private String email;
    private String password;
    private String fullName;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    private Boolean active;

    // 構造函數
    public User() {}

    public User(Long id, String username, String email, String password,
                String fullName, LocalDateTime createdAt, LocalDateTime updatedAt, Boolean active) {
        this.id = id;
        this.username = username;
        this.email = email;
        this.password = password;
        this.fullName = fullName;
        this.createdAt = createdAt;
        this.updatedAt = updatedAt;
        this.active = active;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }

    public String getFullName() { return fullName; }
    public void setFullName(String fullName) { this.fullName = fullName; }

    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }

    public LocalDateTime getUpdatedAt() { return updatedAt; }
    public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }

    public Boolean isActive() { return active; }
    public void setActive(Boolean active) { this.active = active; }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", email='" + email + '\'' +
                ", fullName='" + fullName + '\'' +
                ", active=" + active +
                '}';
    }
}

package com.example.myfirstapp.repository;

import com.example.myfirstapp.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@Repository
public class UserRepository {

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public UserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * 查詢所有用戶
     */
    public List<User> findAll() {
        String sql = "SELECT id, username, email, password, full_name, " +
                     "created_at, updated_at, active FROM users ORDER BY id";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
    }

    /**
     * 根據 ID 查詢用戶
     */
    public Optional<User> findById(Long id) {
        String sql = "SELECT id, username, email, password, full_name, " +
                     "created_at, updated_at, active FROM users WHERE id = ?";
        try {
            User user = jdbcTemplate.queryForObject(sql,
                new BeanPropertyRowMapper<>(User.class), id);
            return Optional.ofNullable(user);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    /**
     * 根據用戶名查詢用戶
     */
    public Optional<User> findByUsername(String username) {
        String sql = "SELECT id, username, email, password, full_name, " +
                     "created_at, updated_at, active FROM users WHERE username = ?";
        try {
            User user = jdbcTemplate.queryForObject(sql,
                new BeanPropertyRowMapper<>(User.class), username);
            return Optional.ofNullable(user);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    /**
     * 根據電子郵件查詢用戶
     */
    public Optional<User> findByEmail(String email) {
        String sql = "SELECT id, username, email, password, full_name, " +
                     "created_at, updated_at, active FROM users WHERE email = ?";
        try {
            User user = jdbcTemplate.queryForObject(sql,
                new BeanPropertyRowMapper<>(User.class), email);
            return Optional.ofNullable(user);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    /**
     * 檢查用戶名是否存在
     */
    public boolean existsByUsername(String username) {
        String sql = "SELECT COUNT(*) FROM users WHERE username = ?";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class, username);
        return count != null && count > 0;
    }

    /**
     * 檢查電子郵件是否存在
     */
    public boolean existsByEmail(String email) {
        String sql = "SELECT COUNT(*) FROM users WHERE email = ?";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class, email);
        return count != null && count > 0;
    }

    /**
     * 插入新用戶
     */
    public User save(User user) {
        if (user.getId() == null) {
            // 插入新用戶
            String sql = "INSERT INTO users (username, email, password, full_name, " +
                         "created_at, updated_at, active) VALUES (?, ?, ?, ?, ?, ?, ?)";
            LocalDateTime now = LocalDateTime.now();
            jdbcTemplate.update(sql,
                user.getUsername(),
                user.getEmail(),
                user.getPassword(),
                user.getFullName(),
                now,
                now,
                user.isActive() != null ? user.isActive() : true
            );

            // 獲取生成的 ID
            String currSql = "SELECT currval(pg_get_serial_sequence('users', 'id'))";
            Long id = jdbcTemplate.queryForObject(currSql, Long.class);
            user.setId(id);
            user.setCreatedAt(now);
            user.setUpdatedAt(now);
        } else {
            // 更新現有用戶
            String sql = "UPDATE users SET username = ?, email = ?, password = ?, " +
                         "full_name = ?, updated_at = ?, active = ? WHERE id = ?";
            jdbcTemplate.update(sql,
                user.getUsername(),
                user.getEmail(),
                user.getPassword(),
                user.getFullName(),
                LocalDateTime.now(),
                user.isActive(),
                user.getId()
            );
            user.setUpdatedAt(LocalDateTime.now());
        }
        return user;
    }

    /**
     * 刪除用戶
     */
    public void deleteById(Long id) {
        String sql = "DELETE FROM users WHERE id = ?";
        jdbcTemplate.update(sql, id);
    }

    /**
     * 根據名稱搜索用戶
     */
    public List<User> searchByName(String name) {
        String sql = "SELECT id, username, email, password, full_name, " +
                     "created_at, updated_at, active FROM users " +
                     "WHERE username ILIKE ? OR full_name ILIKE ? OR email ILIKE ? " +
                     "ORDER BY id";
        String searchPattern = "%" + name + "%";
        return jdbcTemplate.query(sql,
            new BeanPropertyRowMapper<>(User.class),
            searchPattern, searchPattern, searchPattern);
    }

    /**
     * 統計用戶數量
     */
    public int count() {
        String sql = "SELECT COUNT(*) FROM users";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count != null ? count : 0;
    }

    /**
     * 查詢活躍用戶數量
     */
    public int countActive() {
        String sql = "SELECT COUNT(*) FROM users WHERE active = TRUE";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count != null ? count : 0;
    }
}

6.6 Service 層實作

package com.example.myfirstapp.service;

import com.example.myfirstapp.config.ResourceNotFoundException;
import com.example.myfirstapp.entity.User;
import com.example.myfirstapp.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("User", id));
    }

    public User findByUsername(String username) {
        return userRepository.findByUsername(username)
            .orElseThrow(() -> new ResourceNotFoundException("User not found: " + username));
    }

    public List<User> searchByName(String name) {
        return userRepository.searchByName(name);
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public void deleteById(Long id) {
        if (!userRepository.findById(id).isPresent()) {
            throw new ResourceNotFoundException("User", id);
        }
        userRepository.deleteById(id);
    }

    public boolean existsByUsername(String username) {
        return userRepository.existsByUsername(username);
    }

    public boolean existsByEmail(String email) {
        return userRepository.existsByEmail(email);
    }

    public int count() {
        return userRepository.count();
    }

    public int countActive() {
        return userRepository.countActive();
    }
}

6.7 完整的 Controller 實作

package com.example.myfirstapp.controller;

import com.example.myfirstapp.dto.ApiResponse;
import com.example.myfirstapp.dto.CreateUserRequest;
import com.example.myfirstapp.dto.UserResponse;
import com.example.myfirstapp.entity.User;
import com.example.myfirstapp.service.UserService;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.stream.Collectors;

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

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public ResponseEntity<ApiResponse<List<UserResponse>>> getAllUsers() {
        List<User> users = userService.findAll();
        List<UserResponse> responses = users.stream()
            .map(this::convertToResponse)
            .collect(Collectors.toList());
        return ResponseEntity.ok(ApiResponse.success(responses));
    }

    @GetMapping("/{id}")
    public ResponseEntity<ApiResponse<UserResponse>> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return ResponseEntity.ok(ApiResponse.success(convertToResponse(user)));
    }

    @PostMapping
    public ResponseEntity<ApiResponse<UserResponse>> createUser(
            @Valid @RequestBody CreateUserRequest request) {

        // 檢查用戶名是否存在
        if (userService.existsByUsername(request.getUsername())) {
            return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(ApiResponse.error("用戶名已存在"));
        }

        // 檢查電子郵件是否存在
        if (userService.existsByEmail(request.getEmail())) {
            return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(ApiResponse.error("電子郵件已存在"));
        }

        // 創建用戶
        User user = new User();
        user.setUsername(request.getUsername());
        user.setEmail(request.getEmail());
        user.setPassword(request.getPassword());
        user.setFullName(request.getFullName());
        user.setActive(true);

        User saved = userService.save(user);
        return ResponseEntity
            .status(HttpStatus.CREATED)
            .body(ApiResponse.success(convertToResponse(saved)));
    }

    @PutMapping("/{id}")
    public ResponseEntity<ApiResponse<UserResponse>> updateUser(
            @PathVariable Long id,
            @Valid @RequestBody CreateUserRequest request) {

        User existing = userService.findById(id);

        // 更新用戶信息
        existing.setUsername(request.getUsername());
        existing.setEmail(request.getEmail());
        existing.setPassword(request.getPassword());
        existing.setFullName(request.getFullName());

        User updated = userService.save(existing);
        return ResponseEntity.ok(ApiResponse.success(convertToResponse(updated)));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<ApiResponse<Void>> deleteUser(@PathVariable Long id) {
        userService.deleteById(id);
        return ResponseEntity.ok(ApiResponse.success(null));
    }

    @GetMapping("/search")
    public ResponseEntity<ApiResponse<List<UserResponse>>> searchUsers(
            @RequestParam(name = "name", required = false) String name) {
        List<User> users;
        if (name != null && !name.isEmpty()) {
            users = userService.searchByName(name);
        } else {
            users = userService.findAll();
        }
        List<UserResponse> responses = users.stream()
            .map(this::convertToResponse)
            .collect(Collectors.toList());
        return ResponseEntity.ok(ApiResponse.success(responses));
    }

    @GetMapping("/count")
    public ResponseEntity<ApiResponse<Integer>> getUserCount() {
        return ResponseEntity.ok(ApiResponse.success(userService.count()));
    }

    @GetMapping("/count/active")
    public ResponseEntity<ApiResponse<Integer>> getActiveUserCount() {
        return ResponseEntity.ok(ApiResponse.success(userService.countActive()));
    }

    private UserResponse convertToResponse(User user) {
        UserResponse response = new UserResponse();
        response.setId(user.getId());
        response.setUsername(user.getUsername());
        response.setEmail(user.getEmail());
        response.setFullName(user.getFullName());
        response.setCreatedAt(user.getCreatedAt());
        response.setStatus(user.isActive() ? "ACTIVE" : "INACTIVE");
        return response;
    }
}

Spring Boot 4 入門教學 - Part 5 (HelloWorld REST API)

Cyrus Tse — Sun, 25 Jan 2026 07:00:04 +0000

第五章：建立 HelloWorld REST API

5.1 前言：構建你的第一個 REST API

在這一章節中，我們將學習如何使用 Spring Boot 創建 REST API。REST（Representational State Transfer）是一種軟體架構風格，用於設計網絡應用程式的接口。Spring Boot 提供了強大的支援，讓你可以輕鬆地構建符合 REST 原則的 API。

我們將從最簡單的「Hello World」API 開始，逐步擴展到包含不同類型端點的完整 API。這個過程中，你將學習到 Spring Boot Web 開發的核心概念和最佳實踐。

5.2 @RestController 和 @GetMapping 詳解

@RestController 是 Spring Web 開發中最常用的註解之一。它是 @Controller 和 @ResponseBody 的組合，表示這個類是一個 REST 控制器，其方法的返回值會直接作為 HTTP 響應的內容。

package com.example.myfirstapp.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    /**
     * 最簡單的 GET API
     * 訪問: GET /hello
     */
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }

    /**
     * 帶查詢參數的 API
     * 訪問: GET /hello?name=John
     */
    @GetMapping("/greet")
    public String greet(
            @RequestParam(name = "name", defaultValue = "World") String name) {
        return String.format("Hello, %s! Welcome to Spring Boot!", name);
    }

    /**
     * 帶路徑參數的 API
     * 訪問: GET /hello/John
     */
    @GetMapping("/hello/{name}")
    public String helloPath(
            @PathVariable(name = "name") String name) {
        return String.format("Hello, %s!", name);
    }
}

讓我們詳細分析這個範例：

@RestController 註解標記 HelloController 類為 REST 控制器。當 Spring 處理 HTTP 請求時，它會找到對應的控制器方法並執行。

@GetMapping("/hello") 指定這個方法處理 /hello 的 GET 請求。Spring MVC 會將方法的返回值轉換為 HTTP 響應體。在這個例子中，返回的是 String，Spring 會直接將其寫入響應體。

@RequestParam 用於提取查詢參數。name 參數對應 URL 中的 ?name=John 部分。defaultValue = "World" 指定當沒有提供 name 參數時使用 "World" 作為預設值。

@PathVariable 用於提取路徑參數。在 /hello/{name} 中，{name} 是一個路徑變數，可以通過 @PathVariable 獲取其值。

5.3 HTTP 請求方法對照表

Spring Boot 支援所有 HTTP 請求方法。以下是常見的請求方法對照：

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

    /**
     * GET - 獲取資源
     * 查詢所有用戶: GET /api/users
     * 查詢指定用戶: GET /api/users/{id}
     */
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }

    /**
     * POST - 創建新資源
     * 創建用戶: POST /api/users
     * 請求體包含用戶數據
     */
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }

    /**
     * PUT - 更新資源（完整更新）
     * 更新用戶: PUT /api/users/{id}
     */
    @PutMapping("/{id}")
    public User updateUser(
            @PathVariable Long id,
            @RequestBody User user) {
        user.setId(id);
        return userService.save(user);
    }

    /**
     * PATCH - 部分更新資源
     * 部分更新用戶: PATCH /api/users/{id
     */
    @PatchMapping("/{id}")
    public User partialUpdateUser(
            @PathVariable Long id,
            @RequestBody Map<String, Object> updates) {
        return userService.partialUpdate(id, updates);
    }

    /**
     * DELETE - 刪除資源
     * 刪除用戶: DELETE /api/users/{id}
     */
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteById(id);
    }
}

理解 HTTP 請求方法的語義很重要：

GET：用於獲取資源，應該是冪等的（多次調用結果相同）
POST：用於創建資源，不一定是冪等的
PUT：用於完整更新資源，是冪等的
PATCH：用於部分更新資源，是冪等的
DELETE：用於刪除資源，是冪等的

5.4 @RequestBody 和 @ResponseBody 詳解

@RequestBody 和 @ResponseBody 是處理 HTTP 請求和響應體的核心註解。

@RequestBody 將 HTTP 請求體自動轉換為 Java 物件：

@PostMapping("/users")
public User createUser(@RequestBody User user) {
    // Spring 會自動將 JSON 請求體解析為 User 物件
    return userService.save(user);
}

@ResponseBody 將 Java 物件自動轉換為 HTTP 響應體（@RestController 已包含此功能）：

@PostMapping("/users")
public ResponseEntity<User> createUser(@RequestBody User user) {
    User saved = userService.save(user);
    return ResponseEntity.ok(saved);
}

讓我們創建一個完整的 DTO 類來演示複雜的請求/響應處理：

package com.example.myfirstapp.dto;

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
import java.time.LocalDateTime;

// 創建用戶請求 DTO
public class CreateUserRequest {

    @NotBlank(message = "用戶名不能為空")
    @Size(min = 3, max = 20, message = "用戶名長度必須在 3-20 之間")
    private String username;

    @NotBlank(message = "電子郵件不能為空")
    @Email(message = "電子郵件格式不正確")
    private String email;

    @NotBlank(message = "密碼不能為空")
    @Size(min = 8, message = "密碼長度至少為 8 個字元")
    private String password;

    private String fullName;

    // getters and setters
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getFullName() { return fullName; }
    public void setFullName(String fullName) { this.fullName = fullName; }
}

// 用戶響應 DTO
public class UserResponse {

    private Long id;
    private String username;
    private String email;
    private String fullName;
    private LocalDateTime createdAt;
    private String status;

    // getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getFullName() { return fullName; }
    public void setFullName(String fullName) { this.fullName = fullName; }
    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }

    // 靜態工廠方法
    public static UserResponse fromEntity(User user) {
        UserResponse response = new UserResponse();
        response.setId(user.getId());
        response.setUsername(user.getUsername());
        response.setEmail(user.getEmail());
        response.setFullName(user.getFullName());
        response.setCreatedAt(user.getCreatedAt());
        response.setStatus(user.isActive() ? "ACTIVE" : "INACTIVE");
        return response;
    }
}

// API 統一響應格式
public class ApiResponse<T> {
    private boolean success;
    private String message;
    private T data;
    private LocalDateTime timestamp;
    private String traceId;

    public static <T> ApiResponse<T> success(T data) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setSuccess(true);
        response.setMessage("操作成功");
        response.setData(data);
        response.setTimestamp(LocalDateTime.now());
        response.setTraceId(UUID.randomUUID().toString().substring(0, 8));
        return response;
    }

    public static <T> ApiResponse<T> error(String message) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setSuccess(false);
        response.setMessage(message);
        response.setData(null);
        response.setTimestamp(LocalDateTime.now());
        response.setTraceId(UUID.randomUUID().toString().substring(0, 8));
        return response;
    }

    // getters and setters
    public boolean isSuccess() { return success; }
    public void setSuccess(boolean success) { this.success = success; }
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
    public T getData() { return data; }
    public void setData(T data) { this.data = data; }
    public LocalDateTime getTimestamp() { return timestamp; }
    public void setTimestamp(LocalDateTime timestamp) { this.timestamp = timestamp; }
    public String getTraceId() { return traceId; }
    public void setTraceId(String traceId) { this.traceId = traceId; }
}

5.5 完整的 User API 實作

讓我們創建一個完整的 User API，包含 CRUD 操作：

package com.example.myfirstapp.controller;

import com.example.myfirstapp.dto.ApiResponse;
import com.example.myfirstapp.dto.CreateUserRequest;
import com.example.myfirstapp.dto.UserResponse;
import com.example.myfirstapp.entity.User;
import com.example.myfirstapp.service.UserService;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.stream.Collectors;

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

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    /**
     * 獲取所有用戶
     * GET /api/users
     */
    @GetMapping
    public ResponseEntity<ApiResponse<List<UserResponse>>> getAllUsers() {
        List<User> users = userService.findAll();
        List<UserResponse> responses = users.stream()
            .map(UserResponse::fromEntity)
            .collect(Collectors.toList());
        return ResponseEntity.ok(ApiResponse.success(responses));
    }

    /**
     * 獲取指定用戶
     * GET /api/users/{id}
     */
    @GetMapping("/{id}")
    public ResponseEntity<ApiResponse<UserResponse>> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return ResponseEntity.ok(ApiResponse.success(UserResponse.fromEntity(user)));
    }

    /**
     * 創建用戶
     * POST /api/users
     */
    @PostMapping
    public ResponseEntity<ApiResponse<UserResponse>> createUser(
            @Valid @RequestBody CreateUserRequest request) {

        // 檢查用戶名是否已存在
        if (userService.existsByUsername(request.getUsername())) {
            return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(ApiResponse.error("用戶名已存在"));
        }

        // 檢查電子郵件是否已存在
        if (userService.existsByEmail(request.getEmail())) {
            return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(ApiResponse.error("電子郵件已存在"));
        }

        // 創建用戶
        User user = new User();
        user.setUsername(request.getUsername());
        user.setEmail(request.getEmail());
        user.setPassword(request.getPassword()); // 注意：實際應用中應該加密
        user.setFullName(request.getFullName());

        User saved = userService.save(user);
        return ResponseEntity
            .status(HttpStatus.CREATED)
            .body(ApiResponse.success(UserResponse.fromEntity(saved)));
    }

    /**
     * 更新用戶
     * PUT /api/users/{id}
     */
    @PutMapping("/{id}")
    public ResponseEntity<ApiResponse<UserResponse>> updateUser(
            @PathVariable Long id,
            @Valid @RequestBody CreateUserRequest request) {

        User existing = userService.findById(id);

        // 更新用戶信息
        existing.setUsername(request.getUsername());
        existing.setEmail(request.getEmail());
        existing.setPassword(request.getPassword());
        existing.setFullName(request.getFullName());

        User updated = userService.save(existing);
        return ResponseEntity.ok(ApiResponse.success(UserResponse.fromEntity(updated)));
    }

    /**
     * 刪除用戶
     * DELETE /api/users/{id}
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<ApiResponse<Void>> deleteUser(@PathVariable Long id) {
        userService.deleteById(id);
        return ResponseEntity.ok(ApiResponse.success(null));
    }

    /**
     * 搜索用戶
     * GET /api/users/search?name=john
     */
    @GetMapping("/search")
    public ResponseEntity<ApiResponse<List<UserResponse>>> searchUsers(
            @RequestParam(name = "name", required = false) String name) {
        List<User> users;
        if (name != null && !name.isEmpty()) {
            users = userService.searchByName(name);
        } else {
            users = userService.findAll();
        }
        List<UserResponse> responses = users.stream()
            .map(UserResponse::fromEntity)
            .collect(Collectors.toList());
        return ResponseEntity.ok(ApiResponse.success(responses));
    }
}

5.6 異常處理

一個良好的 API 應該有完善的異常處理機制。讓我們創建一個全局異常處理器：

package com.example.myfirstapp.config;

import com.example.myfirstapp.dto.ApiResponse;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

@RestControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 處理參數驗證錯誤
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiResponse<Map<String, String>>> handleValidationExceptions(
            MethodArgumentNotValidException ex) {

        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getAllErrors().forEach((error) -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            errors.put(fieldName, errorMessage);
        });

        ApiResponse<Map<String, String>> response = new ApiResponse<>();
        response.setSuccess(false);
        response.setMessage("參數驗證失敗");
        response.setData(errors);

        return ResponseEntity
            .status(HttpStatus.BAD_REQUEST)
            .body(response);
    }

    /**
     * 處理資源不存在異常
     */
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ApiResponse<Void>> handleResourceNotFound(
            ResourceNotFoundException ex) {
        return ResponseEntity
            .status(HttpStatus.NOT_FOUND)
            .body(ApiResponse.error(ex.getMessage()));
    }

    /**
     * 處理非法參數異常
     */
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ApiResponse<Void>> handleIllegalArgument(
            IllegalArgumentException ex) {
        return ResponseEntity
            .status(HttpStatus.BAD_REQUEST)
            .body(ApiResponse.error(ex.getMessage()));
    }

    /**
     * 處理通用異常
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<Void>> handleGenericException(Exception ex) {
        return ResponseEntity
            .status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(ApiResponse.error("系統錯誤，請稍後再試"));
    }
}

// 自定義異常類
class ResourceNotFoundException extends RuntimeException {

    public ResourceNotFoundException(String message) {
        super(message);
    }

    public ResourceNotFoundException(String resourceType, Long id) {
        super(String.format("%s not found with id: %d", resourceType, id));
    }
}

5.7 測試 REST API

讓我們使用 curl 命令測試我們的 API：

# 啟動應用程式後執行以下命令

# 1. 獲取所有用戶
curl -X GET http://localhost:8080/api/users

# 2. 創建新用戶
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "username": "john",
    "email": "john@example.com",
    "password": "password123",
    "fullName": "John Doe"
  }'

# 3. 獲取指定用戶（假設 ID 為 1）
curl -X GET http://localhost:8080/api/users/1

# 4. 更新用戶
curl -X PUT http://localhost:8080/api/users/1 \
  -H "Content-Type: application/json" \
  -d '{
    "username": "johnny",
    "email": "johnny@example.com",
    "password": "newpassword456",
    "fullName": "Johnny Doe"
  }'

# 5. 搜索用戶
curl -X GET "http://localhost:8080/api/users/search?name=john"

# 6. 刪除用戶
curl -X DELETE http://localhost:8080/api/users/1

# 7. 測試參數驗證（空的用戶名）
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "username": "",
    "email": "invalid-email",
    "password": "123"
  }'

Spring Boot 4 入門教學 - Part 4 (@Bean 與 IoC 容器)

Cyrus Tse — Sun, 25 Jan 2026 06:59:14 +0000

第四章：@bean 與 IoC 容器

4.1 前言：理解控制反轉與依賴注入

在這一章節中，我們將深入學習 Spring Framework 最重要的兩個概念：控制反轉（Inversion of Control，簡稱 IoC）和依賴注入（Dependency Injection，簡稱 DI）。這些概念是 Spring 的核心，理解它們對於成為一個優秀的 Spring 開發者至關重要。

很多初學者對這些概念感到困惑，因為它們聽起來很抽象。但實際上，這些概念非常簡單，並且在我們的日常開發中處處可見。讓我們通過具體的範例來理解這些概念。

4.2 控制反轉（IoC）的概念

控制反轉是一種軟體設計原則，它顛倒了傳統的程式控制流程。在傳統的程式設計中，我們自己創建和管理物件的依賴關係；而在 IoC 中，這個控制權被反轉給了框架（這裡就是 Spring 容器）。

讓我們通過一個簡單的對比來理解這個概念：

// 傳統方式：類自己負責創建和管理依賴
public class UserService {
    private UserRepository userRepository;

    public UserService() {
        // UserService 負責創建 UserRepository
        this.userRepository = new UserRepository();
    }

    public void createUser(String name) {
        userRepository.save(name);
    }
}

// IoC 方式：依賴由外部提供
@Service
public class UserService {

    private final UserRepository userRepository;

    // 依賴通過構造函數注入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void createUser(String name) {
        userRepository.save(name);
    }
}

在傳統方式中，UserService 直接創建 UserRepository，這導致了以下問題：

緊密耦合：UserService 依賴於 UserRepository 的具體實現
難以測試：無法輕鬆地替換 UserRepository 為 Mock 物件
難以維護：任何 UserRepository 的變化都可能影響 UserService

而在 IoC 方式中，UserRepository 的實例由外部（Spring 容器）提供，這解決了上述所有問題。

4.3 依賴注入（DI）的實現方式

Spring Framework 提供了多種依賴注入的方式：構造函數注入、Setter 注入和欄位注入。讓我們逐一學習。

構造函數注入（推薦）：

@Service
public class UserService {

    private final UserRepository userRepository;

    // 構造函數注入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // ...
}

構造函數注入的優點：

確保物件創建時所有必要的依賴都已注入
便於單元測試
不可變性：依賴可以標記為 final
循環依賴在編譯時就能發現

Setter 注入：

@Service
public class UserService {

    private UserRepository userRepository;

    // Setter 注入
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // ...
}

Setter 注入適用於可選的依賴，或者在運行時可能需要改變的依賴。

欄位注入：

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    // ...
}

欄位注入看起來最簡潔，但有一些缺點：

不便於測試
無法聲明不可變欄位
可能導致循環依賴問題被隱藏

最佳實踐：優先使用構造函數注入。對於可選依賴，可以使用 Setter 注入。

4.4 @bean 註解的深度解析

@Bean 註解用於聲明 Spring 容器應該管理的 Bean。與 @Component 等元件掃描方式不同，@Bean 允許你更精細地控制 Bean 的創建過程。

讓我們創建一個複雜的 @Bean 範例：

package com.example.myfirstapp.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    /**
     * @Bean 註解的方法會被 Spring 容器調用
     * 返回值會被註冊為容器中的 Bean
     */
    @Bean
    @Primary // 標記為主要 Bean，優先注入
    @Scope("singleton") // 預設為單例
    public DataSource dataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setMaximumPoolSize(10);
        dataSource.setMinimumIdle(5);
        dataSource.setConnectionTimeout(30000);
        dataSource.setIdleTimeout(600000);
        dataSource.setMaxLifetime(1800000);
        return dataSource;
    }

    /**
     * 自定義 Bean 名稱
     */
    @Bean(name = "customDataSource")
    public DataSource customDataSource() {
        // 自定義配置
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    /**
     * 工廠 Bean
     */
    @Bean
    public ConnectionFactory connectionFactory() {
        return new ConnectionFactory(/* 配置 */);
    }
}

@Bean 註解支援多種屬性：

name：指定 Bean 的名稱（預設為方法名稱）
autowireMode：配置自動注入模式
initMethod：指定初始化方法
destroyMethod：指定銷毀方法
autowireCandidate：標記是否可以被自動注入

@Bean(
    name = {"myBean", "myAlternativeBean"},
    autowireMode = Autowire.BY_TYPE,
    initMethod = "initialize",
    destroyMethod = "cleanup",
    autowireCandidate = true
)
public MyService myService() {
    return new MyService();
}

4.5 @Component vs @bean：如何選擇？

在 Spring 中，有兩種主要的方式來註冊 Bean：@Component（配合元件掃描）和 @Bean（在 @Configuration 類中）。讓我們學習如何選擇合適的方式。

使用 @Component 的時機：

// 簡單的元件類
@Component
public class DateFormatter {
    public String formatDate(java.time.LocalDate date) {
        return date.format(java.time.format.DateTimeFormatter.ISO_DATE);
    }
}

// Service 類
@Service
public class UserService {
    // ...
}

// Repository 類
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // ...
}

使用 @Bean 的時機：

@Configuration
public class ThirdPartyConfig {

    // 整合第三方庫
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    // 自定義 Bean 創建邏輯
    @Bean
    public CacheManager cacheManager() {
        // 複雜的創建邏輯
        return new CustomCacheManager(/* 各種配置 */);
    }

    // 多個相同類型的 Bean
    @Bean
    public MessageSource messageSource() {
        ResourceBundleMessageSource source = new ResourceBundleMessageSource();
        source.setBasename("messages");
        return source;
    }
}

選擇指南：

如果類是你自己擁有的原始碼，使用 @Component 及其特化版本（@Service、@Repository）
如果類來自第三方庫或需要複雜的創建邏輯，使用 @Bean
如果需要對 Bean 的創建過程有細粒度控制，使用 @Bean

4.6 Bean 的作用域

Spring 容器中的 Bean 可以有不同的作用域。理解這些作用域對於正確設計應用程式非常重要。

@Configuration
public class BeanScopeConfig {

    // 預設作用域：單例
    @Bean
    public SingletonService singletonService() {
        return new SingletonService();
    }

    // 原型作用域：每次注入都會創建新實例
    @Bean
    @Scope("prototype")
    public PrototypeService prototypeService() {
        return new PrototypeService();
    }

    // 請求作用域（Web 應用）
    @Bean
    @Scope("request")
    public RequestScopedService requestScopedService() {
        return new RequestScopedService();
    }

    // 會話作用域（Web 應用）
    @Bean
    @Scope("session")
    public SessionScopedService sessionScopedService() {
        return new SessionScopedService();
    }
}

各作用域的特點：

singleton（單例）：整個容器中只有一個實例。這是 Spring Boot 的預設作用域，適用於無狀態的服務類。
prototype（原型）：每次注入或從容器獲取時都會創建新實例。適用於有狀態的物件。
request：每個 HTTP 請求創建一個新實例。僅在 Web 環境中有效。
session：每個 HTTP 會話創建一個新實例。僅在 Web 環境中有效。

4.7 依賴注入的進階主題

讓我們學習一些進階的依賴注入主題。

使用 @Qualifier 處理多個相同類型的 Bean：

@Configuration
public class MultiBeanConfig {

    @Bean
    public MessageService emailService() {
        return new EmailMessageService();
    }

    @Bean
    public MessageService smsService() {
        return new SmsMessageService();
    }

    @Bean
    public MessageService pushService() {
        return new PushMessageService();
    }
}

@Service
public class NotificationService {

    private final MessageService messageService;

    // 使用 @Qualifier 指定具體的 Bean
    @Autowired
    public NotificationService(@Qualifier("emailService") MessageService messageService) {
        this.messageService = messageService;
    }

    // 使用 @Primary 標記首選 Bean
    @Bean
    @Primary
    public MessageService defaultMessageService() {
        return new EmailMessageService();
    }
}

使用 @primary 處理歧義：

@Configuration
public class PrimaryConfig {

    @Bean
    @Primary
    public FileStorage primaryStorage() {
        return new S3FileStorage();
    }

    @Bean
    public FileStorage localStorage() {
        return new LocalFileStorage();
    }
}

使用 @profile 根據環境選擇 Bean：

@Configuration
public class ProfileConfig {

    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        // 開發環境的資料來源
        return new HikariDataSource(/* dev config */);
    }

    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        // 生產環境的資料來源
        return new HikariDataSource(/* prod config */);
    }
}

4.8 實戰：構建配置類

讓我們通過一個完整的實戰範例來整合這一章學習的知識：

package com.example.myfirstapp.config;

import com.example.myfirstapp.service.CalculatorService;
import com.example.myfirstapp.service.impl.SimpleCalculatorService;
import com.example.myfirstapp.service.impl.ScientificCalculatorService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;

@Configuration
public class CalculatorConfig {

    /**
     * 簡單計算機服務 - 預設 Bean
     */
    @Bean
    @Primary
    @Profile({"default", "dev", "test"})
    public CalculatorService simpleCalculatorService() {
        return new SimpleCalculatorService();
    }

    /**
     * 科學計算機服務 - 生產環境
     */
    @Bean
    @Profile("prod")
    public CalculatorService scientificCalculatorService() {
        return new ScientificCalculatorService();
    }

    /**
     * 自定義日誌配置
     */
    @Bean
    public LoggingService loggingService(CalculatorService calculatorService) {
        return new LoggingService(calculatorService);
    }
}

// CalculatorService 接口
interface CalculatorService {
    int add(int a, int b);
    int subtract(int a, int b);
    int multiply(int a, int b);
    int divide(int a, int b);
}

// LoggingService 類
class LoggingService {

    private final CalculatorService calculatorService;

    public LoggingService(CalculatorService calculatorService) {
        this.calculatorService = calculatorService;
    }

    public int logAndCalculate(String operation, int a, int b) {
        System.out.println("執行操作: " + operation + "，參數: " + a + ", " + b);
        int result = switch (operation) {
            case "add" -> calculatorService.add(a, b);
            case "subtract" -> calculatorService.subtract(a, b);
            case "multiply" -> calculatorService.multiply(a, b);
            case "divide" -> calculatorService.divide(a, b);
            default -> throw new IllegalArgumentException("不支持的操作: " + operation);
        };
        System.out.println("結果: " + result);
        return result;
    }
}

這個範例展示了：

多個相同類型 Bean 的處理（使用 @Primary）
基於環境的 Bean 選擇（使用 @Profile）
構造函數注入
Bean 之間的依賴關係

Spring Boot 4 入門教學 - Part 3 (@SpringBootApplication 深度解析)

Cyrus Tse — Sun, 25 Jan 2026 06:58:08 +0000

第三章：@SpringBootApplication 深度解析

3.1 前言：揭開@SpringBootApplication的神秘面纱

在上一章中，我們使用了 @SpringBootApplication 註解來標記主應用程式類。這個註解是 Spring Boot 的核心之一，但很多初學者只是機械地使用它，而不理解它背後的原理。在這一章節中，我們將深入探索 @SpringBootApplication 的組成和工作原理，讓你能夠真正理解 Spring Boot 的「魔法」。

理解這個註解不僅是為了滿足好奇心，更是為了成為一個優秀的 Spring Boot 開發者。當你遇到問題時，了解這些基礎概念可以幫助你更快地定位和解決問題。同時，這些知識也會讓你在閱讀官方文檔和源碼時更加得心應手。

3.2 @SpringBootApplication 的三個組成註解

@SpringBootApplication 實際上是一個組合註解（或稱為元註解），它由三個重要的註解組成。讓我們逐一分析每個組成部分。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@EnableAutoConfiguration
@ComponentScan
public @interface SpringBootApplication {
    // 屬性配置
}

這段程式碼顯示 @SpringBootApplication 被標記了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 三個註解。這意味著當你使用 @SpringBootApplication 時，這三個註解的功能都會被啟用。

3.3 @Configuration：配置類的核心

@Configuration 是 Spring Framework 的核心註解之一，它標記一個類作為 Bean 定義的來源。讓我們詳細了解這個註解的作用和用法。

@Configuration 註解表明其標記的類是一個配置類，可以包含 @Bean 註解的方法。這些方法會被 Spring 容器調用，返回的對象會被註冊為 Spring 容器中的 Bean。

讓我們通過一個實際的範例來理解 @Configuration：

package com.example.myfirstapp.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class AppConfig {

    /**
     * @Bean 註解標記的方法會被 Spring 容器調用，
     * 返回的對象會被註冊為容器中的 Bean。
     * 預設 Bean 的名稱就是方法名稱（這裡是 "restTemplate"）。
     */
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    /**
     * 自定義 Bean 名稱
     */
    @Bean(name = "customRestTemplate")
    public RestTemplate customRestTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        // 自定義配置...
        return restTemplate;
    }
}

在這個範例中，AppConfig 類被標記為 @Configuration，這意味著 Spring 會將其視為配置類。類中的 restTemplate() 方法被 @Bean 註解標記，當 Spring 容器啟動時，它會調用這個方法並將返回的 RestTemplate 對象註冊為 Bean。

你可能會問：為什麼需要 @Configuration？為什麼不能直接使用 @Component？這是一個很好的問題。讓我們通過一個對比來理解：

// 使用 @Configuration
@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService(myRepository());
    }

    @Bean
    public MyRepository myRepository() {
        return new MyRepository();
    }
}

// 使用 @Component（不推薦）
@Component
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService(myRepository());
    }

    @Bean
    public MyRepository myRepository() {
        return new MyRepository();
    }
}

這兩種寫法的關鍵區別在於：使用 @Configuration 時，Spring 會確保 Bean 之間的依賴關係被正確處理。如果你從同一個 @Configuration 類中的多個 @Bean 方法請求 Bean，Spring 會確保每次都返回同一個 Bean 實例（單例模式）。而使用 @Component 時，每次調用都會創建新的實例。

這是因為 @Configuration 類會被 CGLIB 代理，代理類會攔截所有 @Bean 方法的調用，確保它們返回的是容器中已存在的 Bean 實例，而不是每次都創建新的實例。

3.4 @EnableAutoConfiguration：自動配置的原理

@EnableAutoConfiguration 是 Spring Boot 特有的註解，它負責自動配置你的 Spring 應用程式。這個註解是 Spring Boot「約定優於配置」哲學的核心。

讓我們了解自動配置的工作原理。當 Spring Boot 啟動時，它會掃描類路徑中的各種條件，根據這些條件自動配置適合的 Bean。例如：

如果類路徑中包含 spring-boot-starter-web，自動配置會設置 Tomcat 內嵌伺服器
如果類路徑中包含 HibernateJpaAutoConfiguration，自動配置會設置 JPA 和 Hibernate
如果類路徑中包含 DataSourceAutoConfiguration，自動配置會設置資料來源

這種自動配置的機制是通過 @Conditional 系列註解實現的。讓我們看看一些常用的條件註解：

// 條件：當類路徑中存在某個類時才配置
@ConditionalOnClass(name = "org.postgresql.Driver")
public class PostgreSqlDataSourceConfiguration {
    // 配置邏輯
}

// 條件：當配置文件中存在某個屬性時才配置
@ConditionalOnProperty(prefix = "spring.datasource", name = "url")
public class DataSourceConfiguration {
    // 配置邏輯
}

// 條件：當類路徑中缺少某個類時才配置
@ConditionalOnMissingClass("org.hibernate.Version")
public class AlternativeConfiguration {
    // 配置邏輯
}

// 條件：當應用程式是 Web 應用程式時才配置
@ConditionalOnWebApplication
public class WebMvcConfiguration {
    // 配置邏輯
}

你可以創建自己的自動配置類。以下是一個自定義自動配置的範例：

package com.example.myfirstapp.autoconfigure;

import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@AutoConfiguration
@ConditionalOnClass(MyService.class)
public class MyAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyService();
    }
}

要讓 Spring Boot 識別你的自動配置，需要在 src/main/resources/META-INF/spring.factories 文件中註冊：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.myfirstapp.autoconfigure.MyAutoConfiguration

3.5 @ComponentScan：元件掃描的機制

@ComponentScan 負責掃描指定包及其子包中的類，將標記為 @Component、@Service、@Repository、@Controller 等註解的類註冊為 Spring 容器中的 Bean。

讓我們通過一個詳細的範例來理解元件掃描的工作原理：

package com.example.myfirstapp;

// 主應用程式類（Spring Boot 3.2.0+，預設掃描 com.example.myfirstapp 及其子包）
@SpringBootApplication
public class MyFirstAppApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyFirstAppApplication.class, args);
    }
}

在這個範例中，由於 @SpringBootApplication 包含 @ComponentScan，Spring 會自動掃描 com.example.myfirstapp 包及其所有子包下的類。

讓我們看看不同類型的元件：

// @Controller：表示這是一個 Web 控制器
package com.example.myfirstapp.controller;

@Controller
public class UserController {
    // 處理 HTTP 請求
}

// @Service：表示這是一個服務類
package com.example.myfirstapp.service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}

// @Repository：表示這是一個資料存取類
package com.example.myfirstapp.repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // JPA 自動實現
}

// @Component：通用元件
package com.example.myfirstapp.util;

@Component
public class DateUtils {
    public String formatDate(LocalDateTime date) {
        return date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }
}

Spring 會自動掃描這些類並將它們註冊為 Bean。在上面的範例中：

UserController 會被註冊為 Bean，並且因為它標記了 @Controller，它還會處理 HTTP 請求
UserService 會被註冊為 Bean，Spring 會自動處理它的依賴注入
UserRepository 會被註冊為 Bean，Spring Data JPA 會自動創建實現類
DateUtils 會被註冊為 Bean，可以在其他地方注入使用

自定義元件掃描的範圍也是可以的：

// 自定義掃描範圍
@SpringBootApplication
@ComponentScan(
    basePackages = {"com.example.myfirstapp", "com.example.common"},
    excludeFilters = @ComponentScan.Filter(type = FilterType.REGEX, pattern = ".*Test")
)
public class MyFirstAppApplication {
    // ...
}

3.6 理解 Spring 容器和 Bean 生命週期

要真正理解 @SpringBootApplication 的運作方式，我們需要了解 Spring 容器和 Bean 的生命週期。

Spring 容器（也稱為 ApplicationContext）是 Spring Framework 的核心。它負責創建、配置和管理 Bean。以下是容器的主要職責：

Bean 的實例化
依賴注入
Bean 的配置
Bean 的生命週期管理

Bean 的生命週期包含以下階段：

package com.example.myfirstapp.service;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

@Service
public class LifecycleDemoService implements BeanNameAware, InitializingBean, DisposableBean {

    private String beanName;

    // 構造函數
    public LifecycleDemoService() {
        System.out.println("1. 構造函數被調用");
    }

    // BeanNameAware 接口方法
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("2. Bean 名稱已設置: " + beanName);
    }

    // @PostConstruct 註解的方法
    @PostConstruct
    public void init() {
        System.out.println("3. @PostConstruct 初始化方法被調用");
    }

    // InitializingBean 接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("4. afterPropertiesSet() 被調用");
    }

    // 業務方法
    public void doSomething() {
        System.out.println("5. 執行業務邏輯");
    }

    // @PreDestroy 註解的方法
    @PreDestroy
    public void cleanup() {
        System.out.println("6. @PreDestroy 清理方法被調用");
    }

    // DisposableBean 接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("7. destroy() 被調用");
    }
}

這個範例展示了 Bean 生命週期的各個階段。當 Spring 容器啟動時，它會按照特定的順序調用這些方法。理解這個順序對於除錯和優化應用程式非常重要。

3.7 實戰：自定義 Spring Boot 應用程式

現在讓我們通過一個實戰專案來整合我們學到的知識。我們將創建一個可配置的自定義應用程式：

package com.example.myfirstapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@SpringBootApplication
public class MyFirstAppApplication {

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

@Configuration
class CustomConfig {

    // 自定義配置 Bean
    @Bean
    public AppSettings appSettings() {
        AppSettings settings = new AppSettings();
        settings.setAppName("My First Spring Boot App");
        settings.setVersion("1.0.0");
        settings.setEnvironment("development");
        return settings;
    }
}

class AppSettings {
    private String appName;
    private String version;
    private String environment;

    // getters and setters
    public void printInfo() {
        System.out.println("=================================");
        System.out.println("應用名稱: " + appName);
        System.out.println("版本: " + version);
        System.out.println("環境: " + environment);
        System.out.println("=================================");
    }

    // getters and setters
    public String getAppName() { return appName; }
    public void setAppName(String appName) { this.appName = appName; }
    public String getVersion() { return version; }
    public void setVersion(String version) { this.version = version; }
    public String getEnvironment() { return environment; }
    public void setEnvironment(String environment) { this.environment = environment; }
}

現在我們可以在任何地方注入 AppSettings Bean 來使用配置：

package com.example.myfirstapp.service;

import com.example.myfirstapp.AppSettings;
import org.springframework.stereotype.Service;

@Service
public class InfoService {

    private final AppSettings appSettings;

    // 構造函數注入（推薦方式）
    public InfoService(AppSettings appSettings) {
        this.appSettings = appSettings;
    }

    public void displayInfo() {
        appSettings.printInfo();
    }
}

3.8 常見問題與解答

在這一章中，我們學習了 @SpringBootApplication 的深度知識。以下是一些常見問題的解答：

問題一：為什麼我的 Bean 沒有被注入？這通常是由於元件掃描範圍不正確造成的。確保被標記為 @Component、@Service、@Repository 等註解的類位於主應用程式類的包或其子包中。如果需要掃描其他包，可以使用 @ComponentScan 註解自定義掃描範圍。

問題二：@Configuration 和 @Component 有什麼區別？如前所述，@Configuration 類會被 CGLIB 代理，確保 @Bean 方法之間的依賴關係被正確處理。如果你只需要將類註冊為 Bean，且不需要這種代理行為，可以使用 @Component。

問題三：如何排除特定的自動配置？可以使用 @SpringBootApplication 的 exclude 屬性：

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class MyApplication {
    // ...
}

Spring Boot 4 入門教學 - Part 2 (建立第一個 Spring Boot 專案)

Cyrus Tse — Sun, 25 Jan 2026 06:57:04 +0000

第二章：建立第一個 Spring Boot 專案

2.1 前言：從這裡開始你的 Spring Boot 之旅

歡迎來到 Spring Boot 的世界！在這一章節中，我們將一步一步地建立你的第一個 Spring Boot 專案。這個過程將讓你體驗到 Spring Boot 的設計哲學：約定優於配置（Convention over Configuration）。Spring Boot 的目標是讓你可以快速啟動並運行應用程式，而不需要處理繁瑣的 XML 配置。

建立 Spring Boot 專案有多種方式，我們將介紹最常用的幾種方法。無論你選擇哪種方式，最終都會得到一個結構一致、可以立即運行的專案。讓我們開始吧！

2.2 使用 Spring Initializr 建立專案

Spring Initializr（https://start.spring.io/）是 Spring 官方提供的專案生成工具，它是建立 Spring Boot 專案最簡單、最推薦的方式。這個工具允許你通過 Web 界面或命令行來生成專案骨架。

讓我們通過 Web 界面來建立專案：

打開瀏覽器，訪問 https://start.spring.io/
選擇專案類型：Maven Project（推薦）或 Gradle Project
選擇語言：Java
選擇 Spring Boot 版本：選擇最新的穩定版本（如 3.2.0 或 4.0.0）
填寫專案元數據：
- Group：你的組織域名反轉（如 com.example）
- Artifact：專案名稱（如 my-first-app）
- Name：專案顯示名稱（通常與 Artifact 相同）
- Description：專案描述
- Package Name：套件名稱（通常為 Group.Artifact）
選擇打包方式：Jar（推薦）或 War
選擇 Java 版本：17 或 21
點擊「ADD DEPENDENCIES」按鈕，添加必要的依賴：
- Spring Web：用於構建 Web 應用程式
- Spring Data JPA：用於資料庫操作
- PostgreSQL Driver：PostgreSQL 資料庫驅動
- Spring Boot DevTools：開發工具（可選但推薦）
點擊「GENERATE」按鈕下載專案壓縮檔

下載完成後，將壓縮檔解壓到你的工作目錄。讓我們用 IntelliJ IDEA 打開這個專案。

2.3 IntelliJ IDEA 整合設定

IntelliJ IDEA 是開發 Spring Boot 應用程式的最佳選擇，它提供了深度的 Spring 支援，包括自動完成、程式碼導航、重構工具等。讓我們來設定你的開發環境。

首次在 IntelliJ IDEA 中打開專案時，IDE 會自動識別 Maven 專案並下載所需的依賴。這個過程可能需要幾分鐘，具體時間取決於你的網絡速度。

以下是一些推薦的 IDE 設定，可以提升你的開發效率：

首先，啟用自動匯入（Auto Import）功能。這樣每當你修改 pom.xml 文件時，IDEA 會自動更新專案依賴。

其次，配置 JDK。確保 IDEA 使用正確的 JDK 版本：打開「File」→「Project Structure」，在「Project Settings」→「Project」中選擇正確的 JDK 版本。

第三，啟用 Spring Boot 支援。在「File」→「Settings」→「Plugins」中確保 Spring Boot 插件已啟用。

第四，配置 Lombok 支援。如果你使用了 Lombok，需要確保 Lombok 插件已安裝並啟用注解處理。

2.4 專案結構詳解

讓我們來詳細了解 Spring Boot 專案的標準結構。這個結構是經過精心設計的，遵循了 Spring 的最佳實踐。

my-first-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── myfirstapp/
│   │   │               ├── MyFirstAppApplication.java
│   │   │               ├── controller/
│   │   │               ├── service/
│   │   │               ├── repository/
│   │   │               ├── entity/
│   │   │               └── config/
│   │   └── resources/
│   │       ├── application.properties
│   │       ├── application.yml
│   │       └── static/
│   │           └── templates/
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── myfirstapp/
├── pom.xml
└── mvnw

這個結構的每個部分都有其特定的用途：

src/main/java 目錄包含你的 Java 源代碼。這是放置所有 Java 類的地方。標準的做法是按照套件名稱組織類，這有助於保持程式碼的結構化和可維護性。

src/main/resources 目錄包含非 Java 資源，如配置文件、靜態資源（CSS、JavaScript、圖片）和模板文件。Spring Boot 會自動載入這個目錄下的資源。

src/test/java 目錄包含測試程式碼。Spring Boot 測試支援讓你可以輕鬆地編寫單元測試和整合測試。

pom.xml 是 Maven 的專案對象模型文件，定義了專案的依賴、插件和其他配置。

2.5 第一個 Spring Boot 應用程式

現在讓我們創建你的第一個 Spring Boot 應用程式。這將是一個簡單的「Hello World」API，返回一個問候訊息。

首先，修改主應用程式類：

package com.example.myfirstapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyFirstAppApplication {

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

這個類是 Spring Boot 應用程式的入口點。@SpringBootApplication 註解標記這是一個 Spring Boot 應用程式，並啟用自動配置和元件掃描。main 方法使用 SpringApplication.run() 來啟動應用程式。

現在，讓我們創建一個簡單的 REST 控制器：

package com.example.myfirstapp.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(
            @RequestParam(name = "name", defaultValue = "World") String name) {
        return String.format("Hello, %s! Welcome to Spring Boot!", name);
    }

    @GetMapping("/")
    public String home() {
        return "<h1>Welcome to Spring Boot!</h1>" +
               "<p>Visit <a href=\"/hello?name=Spring\">/hello?name=Spring</a> for a greeting.</p>";
    }
}

這個控制器定義了兩個端點：/ 返回一個簡單的 HTML 頁面，/hello 接受一個可選的 name 參數並返回問候訊息。

2.6 配置 PostgreSQL 資料庫連接

在這個章節中，我們將學習如何配置 Spring Boot 連接到 PostgreSQL 資料庫。這個配置將在我們的應用程式中使用。

首先，確保你已經在 PostgreSQL 中創建了資料庫。你可以通過 psql 命令列工具或 pgAdmin 來完成：

-- 登入 PostgreSQL
psql -U postgres

-- 創建資料庫
CREATE DATABASE myapp_db;

-- 創建用戶（可選）
CREATE USER myapp_user WITH ENCRYPTED PASSWORD 'your_password';
GRANT ALL PRIVILEGES ON DATABASE myapp_db TO myapp_user;

-- 連接到資料庫並創建資料表
\c myapp_db

-- 授權用戶訪問 public schema
GRANT ALL ON SCHEMA public TO myapp_user;

現在，讓我們配置 Spring Boot 連接到 PostgreSQL。在 src/main/resources/application.properties 文件中添加以下配置：

# PostgreSQL 資料庫配置
spring.datasource.url=jdbc:postgresql://localhost:5432/myapp_db
spring.datasource.username=myapp_user
spring.datasource.password=your_password
spring.datasource.driver-class-name=org.postgresql.Driver

# JPA/Hibernate 配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

# 伺服器配置
server.port=8080

# 日誌配置
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

這個配置包含以下重要設定：

spring.datasource.url 是 JDBC 連接 URL，格式為 jdbc:postgresql://主機:埠/資料庫名稱。

spring.datasource.username 和 spring.datasource.password 是資料庫的登入憑據。

spring.datasource.driver-class-name 指定了 JDBC 驅動程式類別。

spring.jpa.hibernate.ddl-auto=update 讓 Hibernate 自動根據實體類創建或更新資料表結構。這在開發環境中非常方便，但在生產環境中建議使用 validate 或 none。

spring.jpa.show-sql=true 讓 Hibernate 在執行 SQL 語句時輸出日誌，這對於除錯很有幫助。

2.7 運行和測試應用程式

現在讓我們運行並測試你的第一個 Spring Boot 應用程式。有多種方式可以運行 Spring Boot 應用程式。

通過 IDE 運行：在 IntelliJ IDEA 中，找到 MyFirstAppApplication 類，右鍵點擊並選擇「Run 'MyFirstAppApplication.main()'」。Spring Boot 會啟動內嵌的 Tomcat 伺服器（預設端口 8080），並載入你的應用程式。

通過命令列運行：在專案根目錄下執行以下命令：

# 使用 Maven 運行
./mvnw spring-boot:run

# 或者先打包再運行
./mvnw package
java -jar target/my-first-app-0.0.1-SNAPSHOT.jar

應用程式啟動後，你可以通過瀏覽器或 curl 測試 API：

# 測試首頁
curl http://localhost:8080/

# 測試 Hello API（使用預設值）
curl http://localhost:8080/hello

# 測試 Hello API（使用自訂名稱）
curl http://localhost:8080/hello?name=Spring

# 使用 URL 編碼的特殊字符
curl "http://localhost:8080/hello?name=%E5%BC%80%E5%8F%91%E8%80%85"

如果一切正常，你應該能看到類似以下的輸出：

Hello, World! Welcome to Spring Boot!

# 或

Hello, Spring! Welcome to Spring Boot!

恭喜你！你已經成功創建並運行了你的第一個 Spring Boot 應用程式。在接下來的章節中，我們將深入學習 Spring Boot 的核心概念，並構建一個更完整的資料庫驅動應用程式。

2.8 開發環境的最佳實踐

在結束這一章之前，讓我們討論一些 Spring Boot 開發的最佳實踐，這些實踐可以幫助你成為更高效的 Spring Boot 開發者。

首先是使用 Spring Boot DevTools。這個工具提供了許多開發時的便利功能，包括：

快速重啟：當類路徑中的文件發生變化時，應用程式會自動重啟
LiveReload：自動刷新瀏覽器（需要瀏覽器擴展）
遠程開發：支援遠程除錯和更新

要啟用 DevTools，只需在 pom.xml 中添加依賴：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
</dependency>

其次是使用 profiles 來管理不同環境的配置。你可以創建多個配置文件，如 application-dev.properties 用於開發環境，application-prod.properties 用於生產環境。然後通過 spring.profiles.active 來指定使用哪個配置。

第三是善用 application.yml。相比於 application.properties，YAML 格式更加結構化和易讀，特別適合複雜的配置。

第四是定期更新 Spring Boot 版本。Spring Boot 團隊會定期發布更新版本，這些更新通常包含 bug 修復、性能改進和安全修補。使用最新穩定版本可以讓你受益於這些改進。

Spring Boot 4 入門教學 - Part 1 (Spring Boot 4 與 3 的差異)

Cyrus Tse — Sun, 25 Jan 2026 06:19:56 +0000

從零開始建構專業的 Java Web 應用程式

第一章：Spring Boot 4 與 Spring Boot 3 的差異

1.1 前言：為什麼需要了解版本差異

在開始學習 Spring Boot 之前，了解 Spring Boot 4 與 Spring Boot 3 之間的差異至關重要。這不僅是為了選擇正確的版本，更是為了理解 Java 生態系統的演進方向。Spring Boot 3 代表了一個重要的里程碑，它標誌著 Java 企業級開發進入了一個新的時代。許多開發者仍然在使用 Spring Boot 2.x 版本，這些專案最終都需要遷移到新版，而新專案則應該直接從 Spring Boot 3 或 4 開始。

Spring Boot 3 於 2022 年 11 月發布，帶來了革命性的變化。這個版本要求 Java 17 或更高版本，這意味著它完全拥抱了現代 Java 的新特性。對於剛開始學習 Spring Boot 的你來說，直接學習 Spring Boot 4 或至少是 Spring Boot 3.2+ 是最明智的選擇。這些版本不僅提供了更好的性能，還擁有更現代化的 API 設計和更完善的安全機制。

理解版本之間的差異可以幫助你在未來的職業生涯中更好地適應變化。企業級應用通常會在版本穩定後才進行升級，因此你可能會在工作中遇到各種不同版本的 Spring Boot。了解這些差異將使你能夠快速適應任何版本的專案，成為團隊中不可或缺的技術人才。

1.2 Java 版本需求的根本性變化

Spring Boot 3 以及即將到來的 Spring Boot 4 對 Java 版本有嚴格的要求。這是 Spring 框架對現代 Java 特性的拥抱，也是推動整個 Java 生態系統前進的重要舉措。讓我們詳細探討這些變化及其對開發者的影響。

首先，Spring Boot 3.x 要求 Java 17 或更高版本。這意味著如果你仍在使用 Java 8、11 或 13、15，你需要升級你的 JDK。Java 17 是目前、長期支援版本之一，它引入了許多重要的新特性，包括 records、sealed classes、pattern matching for switch expressions 等等。這些特性不僅讓程式碼更加簡潔，還提高了開發效率和類型安全性。

Java 17 帶來的主要新特性值得我們深入了解。Records 是其中最重要的特性之一，它為簡單的資料傳輸對象提供了簡潔的語法。傳統上，我們需要為每個 POJO 撰寫大量的 getter、setter、equals、hashCode 和 toString 方法，而使用 records 這些都可以自動生成。Sealed classes 允許類設計者控制哪些類可以繼承某個類，這在設計 API 時特別有用，可以防止未經授權的子類化。Pattern matching for switch expressions 讓我們可以用更簡潔的方式處理複雜的條件邏輯。

對於 Spring Boot 4，預計會要求 Java 21 或更高版本。Java 21 是最新的 LTS 版本，引入了 virtual threads（專案 Loom）、pattern matching for switch 的完整支援、以及更多的現代化特性。Virtual threads 是 Java 並發程式設計的重大突破，它允許我們創建數以百萬計的輕量級執行緒，這對於構建高並發的 Web 應用程式來說是一個遊戲規則的改變。

升級 Java 版本需要考慮的因素包括：團隊的技能水平、現有專案的相容性、第三方庫的支援情況、以及部署環境的要求。在生產環境中升級 JDK 需要謹慎規劃和充分測試。建議使用 Docker 容器化部署，這樣可以更容易地控制執行環境。

1.3 Jakarta EE 遷移：從 javax 到 jakarta

Spring Boot 3 最大的變化之一是從 Java EE 遷移到 Jakarta EE。這不是簡單的名稱更換，而是整個生態系統的重大重構。讓我們詳細了解這個遷移的背景、過程和影響。

Java EE 曾經是企業級 Java 開發的標準規範。然而，在 2018 年 Eclipse Foundation 接手了這個規範，並將其重新命名為 Jakarta EE。這個決定是為了確保這個規範能夠在開源社區中繼續發展，而不受任何商業公司的控制。遷移過程中，所有的套件名稱都需要從 javax.* 改為 jakarta.*。

這個變化影響了幾乎所有的企業級 Java 規範，包括：JPA（Jakarta Persistence）、Servlet（Jakarta Servlet）、JAX-RS（Jakarta RESTful Web Services）、Bean Validation（Jakarta Validation）、以及 CDI（Jakarta Contexts and Dependency Injection）。這意味著如果你有一個使用 Spring Boot 2.x 的專案需要遷移到 Spring Boot 3，你需要更新所有使用這些規範的程式碼。

讓我們看一些具體的遷移範例。首先是 JPA 實體的遷移：

// Spring Boot 2.x (舊版)
package com.example.demo.entity;

import javax.persistence.*;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;

@Entity
@Table(name = "users")
public class User {

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

    @NotBlank(message = "用戶名不能為空")
    @Size(min = 3, max = 50)
    @Column(name = "username", nullable = false, unique = true)
    private String username;

    @NotBlank(message = "電子郵件不能為空")
    @Email(message = "請輸入有效的電子郵件格式")
    @Column(name = "email", nullable = false, unique = true)
    private String email;

    @NotBlank(message = "密碼不能為空")
    @Size(min = 8, message = "密碼長度至少需要 8 個字元")
    @Column(name = "password", nullable = false)
    private String password;

    // getters and setters
}

// Spring Boot 3.x/4.x (新版)
package com.example.demo.entity;

import jakarta.persistence.*;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;

@Entity
@Table(name = "users")
public class User {

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

    @NotBlank(message = "用戶名不能為空")
    @Size(min = 3, max = 50)
    @Column(name = "username", nullable = false, unique = true)
    private String username;

    @NotBlank(message = "電子郵件不能為空")
    @Email(message = "請輸入有效的電子郵件格式")
    @Column(name = "email", nullable = false, unique = true)
    private String email;

    @NotBlank(message = "密碼不能為空")
    @Size(min = 8, message = "密碼長度至少需要 8 個字元")
    @Column(name = "password", nullable = false)
    private String password;

    // getters and setters
}

如你所見，主要的變化是將所有 javax 開頭的 import 語句替換為 jakarta 開頭。這看起來很簡單，但在大型專案中，這可能涉及到數百甚至數千個檔案的修改。

Servlet 和 Filter 的遷移同樣需要更新套件名稱：

// Spring Boot 2.x (舊版)
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpFilter;

// Spring Boot 3.x/4.x (新版)
import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpFilter;

Spring Security 的遷移也涉及類似的變化：

// Spring Boot 2.x (舊版)
import javax.servlet.http.HttpServletRequest;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

// Spring Boot 3.x/4.x (新版)
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

對於第三方庫，你需要確保它們已經支援 Jakarta EE。主流的庫如 Hibernate、Jackson、Lombok 等都已經提供了支援 Jakarta EE 的版本。在遷移過程中，你可能需要更新這些庫的版本。

1.4 Spring Security 6.x 的重要變化

Spring Security 6.x 帶來了許多重要的改進，包括更現代化的 API 設計、強化的安全預設、以及更好的效能。讓我們詳細了解這些變化。

首先是配置方式的變化。Spring Security 6.x 引入了新的 DSL（領域特定語法）風格配置，這使得安全配置更加聲明式和易讀：

// Spring Security 5.x (舊版配置方式)
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/public/**").permitAll()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .and()
            .httpBasic();
    }
}

// Spring Security 6.x (新版配置方式)
@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/", true)
                .permitAll()
            )
            .httpBasic(Customizer.withDefaults());

        return http.build();
    }
}

注意幾個重要的變化：WebSecurityConfigurerAdapter 已被棄用，取而代之的是返回 SecurityFilterChain Bean 的方式。authorizeRequests() 變成了 authorizeHttpRequests()，antMatchers() 變成了 requestMatchers()。這些變化反映了 Spring Security 向更現代化 API 設計的演進。

另一個重要變化是 CorsFilter 的配置方式也有所改變：

// Spring Security 6.x 新版配置
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .cors(cors -> cors
            .configurationSource(corsConfigurationSource())
        )
        // ... 其他配置

    return http.build();
}

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration configuration = new CorsConfiguration();
    configuration.setAllowedOrigins(Arrays.asList("http://localhost:3000"));
    configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE"));
    configuration.setAllowedHeaders(Arrays.asList("*"));
    configuration.setAllowCredentials(true);

    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", configuration);
    return source;
}

Spring Security 6.x 還引入了對 Spring Authorization Server 的更好整合，這是 OAuth 2.1 和 OpenID Connect 1.0 的官方實現。如果你需要實現社群登入或 OAuth2 認證，Spring Authorization Server 是推薦的解決方案。

1.5 Spring Boot 4 的新功能與未來展望

雖然 Spring Boot 4 還在發展中，但根據 Spring 團隊的公告和社區討論，我們可以預見一些重要的新功能和改進。了解這些趨勢可以幫助你為未來的技術升級做好準備。

首先是對 Java 21 的完整支援。Spring Boot 4 預計會要求 Java 21，這意味著你可以使用 virtual threads、pattern matching 的完整改進、以及其他 Java 21 的新特性。Virtual threads（專案 Loom）是 Java 並發程式設計的重大突破，它允許你創建數以百萬計的輕量級執行緒，而不會消耗大量的記憶體。這對於構建高並發的 Web 應用程式來說是一個革命性的改進。

其次是對原生映像（Native Image）的更好支援。Spring Boot 3 已經引入了對 GraalVM 原生映像的支援，而 Spring Boot 4 將進一步改進這個功能。原生的 Spring Boot 應用程式可以在毫秒級啟動，並使用更少的記憶體，這對於雲原生應用程式和 Serverless 部署來說非常有價值。

第三是對更現代化資料庫技術的支援。隨著資料庫技術的不斷發展，Spring Boot 4 可能會引入對新資料庫特性的更好支援，包括對向量資料庫的整合（這對於 AI 應用程式越來越重要）。

1.6 版本遷移實戰指南

如果你已經有使用 Spring Boot 2.x 的專案需要遷移到 Spring Boot 4，以下是完整的遷移步驟和最佳實踐。這個過程需要謹慎規劃和充分測試，以確保遷移的順利進行。

第一步是評估和規劃。在開始遷移之前，你需要：

盤點專案中使用的所有依賴，確保它們都有支援 Spring Boot 4 的版本
評估自定義程式碼中使用到的 Java EE API，準備進行 Jakarta EE 遷移
建立完整的測試套件，確保遷移後功能不受影響
制定回滾計劃，以防遷移過程中出現嚴重問題

第二步是準備遷移環境。安裝 JDK 21 或更高版本，並確保你的建構工具（Maven 或 Gradle）是最新的版本。

第三步是逐步進行遷移。首先更新 parent POM 或 build.gradle 中的 Spring Boot 版本：

<!-- Maven pom.xml -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version> <!-- 或 4.0.0 -->
    <relativePath/>
</parent>

第四步是更新依賴版本。許多 Spring 生態系統的庫都有針對 Spring Boot 3/4 的特定版本：

<!-- 確保使用正確版本的依賴 -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-bom</artifactId>
    <version>6.2.0</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

第五步是進行 Jakarta EE 遷移。使用 IDE 的重構功能批量替換 javax 為 jakarta。

第六步是更新 Spring Security 配置。將舊的配置方式遷移到新的 DSL 風格。

第七步是運行測試並修復問題。這個階段可能會發現一些遷移相關的問題，需要逐一修復。

1.7 本教學的版本選擇

本教學將以 Spring Boot 3.2+ 為主要版本，因為這是目前最穩定且被廣泛採用的版本。大部分的內容和程式碼都適用於 Spring Boot 4（當它發布時），只有極少數需要 Java 21 的特性會特別標註。

在學習本教學之前，請確保你已經：

安裝 JDK 17 或更高版本（推薦 JDK 21）
安裝 Maven 3.6+ 或 Gradle 8+
安裝 PostgreSQL 資料庫（本地或遠程）
準備好一個現代化的 IDE（推薦 IntelliJ IDEA）

CES 2026: The Year AI Got Real

Cyrus Tse — Wed, 07 Jan 2026 16:50:36 +0000

From smart toilets to thinking robots, CES 2026 showed us that AI is no longer just a buzzword—it's becoming the invisible foundation of everything.

The moment I realized something had shifted was when I saw a smart toilet on the CES show floor.

Not a joke. Not a prototype from a college hackathon. A real product you can order today, for $99, that analyzes your urine to check for dehydration, diabetes, and kidney problems.

Welcome to CES 2026. Where AI stopped being a separate category and became everything.

The Big Picture

Over the past week, I've been sifting through announcements from NVIDIA, AMD, Microsoft, Google, and a handful of startups that aren't household names—yet. And here's the pattern that emerged: AI is no longer a single product or a single app. It's becoming an invisible layer across compute infrastructure, operating systems, consumer electronics, industrial robots, and yes, even your bathroom.

Let me walk you through the seven biggest stories from CES 2026 and explain why they matter.

1. NVIDIA's Rubin: The New Backbone of AI

Jensen Huang took the stage at the Fontainebleau Las Vegas and laid out what he called a blueprint for the future. His message was surprisingly concise: accelerated computing plus AI has fundamentally reshaped computing, and now AI is scaling into every domain and every device.

The centerpiece of that vision is Reuben (sometimes called Vera Rubin), NVIDIA's next-generation architecture. Think of it as the foundation for the next wave of AI models, robots, and self-driving cars.

Here's why this matters: According to Wired, the Rubin chips are already in full production. That means this isn't just a slide deck or a roadmap promise—it's hardware that's shipping. These chips are designed to sharply cut the cost of training and running AI models, which is exactly what you need if you want AI in every device.

But Wait, There's More

NVIDIA didn't stop at data centers. They also announced:

GeForce Now upgrade: Cloud gaming now powered by RTX 5080-class performance, coming to Linux PCs and Amazon Fire TV
DLSS 4.5: Introduces 6x multiframe generation and a second-generation transformer model for super resolution

Over 250 games and apps now support DLSS. The idea is elegant: use increasingly smart AI models to generate extra frames and upscale images, so you get better performance and visuals without needing impossibly powerful local hardware.

The takeaway: NVIDIA's blueprint isn't just about training giant models. It's about turning every screen and device into an AI-accelerated endpoint.

2. AMD's AI PC Push: Your Laptop Gets Serious

Let's be honest: last year's "AI PC" branding didn't exactly light the world on fire. Microsoft's Copilot Plus features weren't killer apps, and most consumers couldn't explain what an NPU actually did.

AMD is betting that changes with the Ryzen AI 400 series.

The flagship Ryzen AI 9 HX475 packs up to 12 Zen 5 CPU cores, boost clocks up to 5.2 GHz, and—most importantly—up to 60 TOPS on the XDNA NPU. That's comfortably above Microsoft's 40 TOPS minimum for Copilot Plus PCs.

AMD is claiming:

30% faster multitasking
70% faster content creation
10% faster gaming
Better battery performance

Here's the shift: This generation isn't about marketing buzzwords. It's about building underlying capability—enough on-device AI horsepower to actually run meaningful models locally, not just call the cloud every time you want to use AI.

The takeaway: While NVIDIA pushes the cloud and data center, AMD is making sure your personal machine can do serious AI work on its own.

3. Microsoft Quietly Solves the Boring Problem

While everyone was watching NVIDIA's keynote, Microsoft made a quieter but potentially transformative announcement: the acquisition of Osmos.

According to the Microsoft blog, Osmos is an agentic AI data engineering platform designed to simplify complex, time-consuming data workflows. In plain English: it uses AI agents to automate cleaning, transforming, and moving data between systems.

The problem they're targeting is real. Organizations have data scattered everywhere—in databases, in spreadsheets, in SaaS tools, in legacy systems—but turning that into something AI can use is still manual, slow, and expensive.

Agentic AI here means autonomous or semi-autonomous agents that can watch your data flows, fix issues, and connect systems with minimal human intervention.

The takeaway: If NVIDIA and AMD are building the compute and hardware for AI, Microsoft is trying to automate the plumbing—the data pipelines that feed those models.

4. Google Gemini: From Your TV to Your Factory Floor

Google pushed AI in two surprising directions at CES 2026.

First, Your Living Room

Google TV is getting a major Gemini update. Google is bringing several Gemini family models to the TV environment, including Nano, Pro, and Ultra.

The headline features:

Generate and watch AI content directly on your big screen
AI-generated visuals, videos, or dynamic backgrounds
Personalized recommendations using on-device or cloud Gemini
Natural language voice control for system settings

The big idea: your TV is no longer just a dumb display with a recommendation engine. It's becoming an AI-native device that can generate and transform media in real time.

Second, Your Factory Floor

This one's wild. According to Wired, Google DeepMind is teaming up with Boston Dynamics to integrate Gemini into the humanoid robot Atlas.

Instead of robots only executing pre-programmed motions, the combination aims to give them higher-level reasoning and adaptability. In theory, robots could understand instructions more like humans, adjust to changing environments, and handle more complex tasks in manufacturing.

The takeaway: Gemini is bridging entertainment and industrial automation. AI is spreading from pure software into media and now into physical systems.

5. Physical AI: When Robots Learn to Reason

This one didn't get as much stage time, but it might be the most important trend.

NVIDIA and Hugging Face announced Cosmos Reason 2, which brings advanced reasoning to physical AI. The focus is on giving AI systems better reasoning capabilities when they interact with the physical world—robots, autonomous machines, and embodied agents.

Physical AI means going beyond pattern recognition on text or images. It means actually understanding cause and effect, spatial relationships, and multi-step tasks in environments with real constraints.

When you connect this with the Gemini-on-Atlas story, you see the broader trend: the AI community is working to give robots not just perception but reasoning. The ability to plan, adapt, and act intelligently in messy, real-world settings.

The takeaway: This is the missing link between current AI and the robot assistants we've been promised in science fiction for decades.

6. AI in Your Bathroom

Yes, we're really talking about this.

Vivu, known for home health analysis, unveiled two products at CES 2026:

The Smart Toilet ($99-129)

Clips onto your existing toilet bowl
Uses optical sensors to monitor hydration levels
Measures specific gravity (can indicate dehydration, diabetes, kidney problems)
Battery handles over 1,000 measurements
Data pushes back to your smartphone app

The Flow Pad ($4-5 per pad)

Menstrual pad infused with microfluidics
Monitors follicle-stimulating hormone (FSH) for fertility and menopause tracking
Scanned with your phone camera

The pricing is notable: no subscription for the smart toilet (after the upfront cost), and disposable pads at a reasonable price point.

The takeaway: AI health monitoring is creeping into everyday objects. No lab visit, no special trip—just passive or semi-passive data collection in your normal routine.

7. Connecting the Dots

Here's where it all comes together:

Layer	Companies	What They're Building
Compute backbone	NVIDIA (Rubin, Blackwell, DLSS)	High-end AI infrastructure
Edge devices	AMD (Ryney AI 400)	On-device AI horsepower
Data plumbing	Microsoft (Osmos)	Automated data pipelines
Reasoning	NVIDIA (Cosmos), Google (Gemini on Atlas)	Physical AI and robot reasoning
Sensors & interfaces	Vivu, Google TV	Consumer AI endpoints

The common thread: AI is becoming invisible. It's not a separate app you open. It's the layer that makes everything else work better.

What This Means for You

None of this will affect you next week. But over the next few years, expect:

Your devices to get smarter locally - AI will run on your laptop and phone without needing the cloud
Robots that can actually think - Factory floors will start using humanoid robots that adapt on the fly
Health monitoring everywhere - Your bathroom, your wearables, your car—all collecting health data passively
AI as infrastructure, not an app - You'll stop "using AI" and start just... doing things, with AI helping in the background

The Bottom Line

CES 2026 wasn't about flashy gadgets (though there were plenty). It was about solidifying the stack that will power the next decade of AI-first experiences.

The companies leading this aren't competing on a single dimension. NVIDIA isn't just GPU anymore. AMD isn't just CPU. Google isn't just search. Microsoft isn't just Office.

They're all building pieces of the same ecosystem: compute, data, reasoning, interfaces, and sensors.

And somewhere in that stack, there's probably a smart toilet involved.

Sources: NVIDIA Blog, Wired Artificial Intelligence, Engadget, Microsoft Blog, Ars Technica, Hugging Face Blog

What story from CES 2026 excites you most? The thinking robots, the smart toilet, or something else? Let me know in the comments.

Why Rust?

Cyrus Tse — Wed, 07 Jan 2026 16:30:24 +0000

"Every programmer remembers the first time their program crashed with a segmentation fault. Or worse—the silent memory corruption that only showed up in production at 3 AM. What if I told you there's a language that catches these bugs at compile time, before they ever ship?"

Introduction

Context:

Modern software faces a paradox: we need high performance AND reliability
Memory safety bugs cause ~70% of security vulnerabilities (Microsoft Security Response Center)
Traditional choices: fast but unsafe (C/C++), safe but slower (Python/Java)

Thesis:

"Rust isn't just another language—it's a breakthrough in language design that finally lets you have both safety AND performance without sacrificing either."

What This Covers:

Core advantages over Go, C++, Java, and Python
Real-world use cases and industry adoption
Honest assessment of the learning curve
How to start your Rust journey

Main Sections

Section 1: The Memory Safety Problem

Key Points:

What are memory safety bugs?
- Buffer overflows, use-after-free, null pointer dereferences
- Example: The 2014 "Heartbleed" bug (OpenSSL)
Why traditional languages struggle:
- C/C++: Manual memory management = human error
- Garbage collected languages (Java/Python): Runtime overhead, pause times
Rust's solution: The Borrow Checker
- Compile-time memory management
- Ownership model: each value has exactly one owner
- Borrowed references are statically verified

Section 2: Rust vs C++ — Same Performance, Zero Compromises

Key Points:

Performance parity:
- Rust generates machine code comparable to C++
- No runtime, no garbage collector overhead
- "Fearless concurrency" — thread safety without data races
Safety without sacrifice:
- C++: undefined behavior is legal
- Rust: compilation fails if safety can't be proven
Real-world comparison:
- Firefox: Rewrote CSS engine in Rust, 2x faster with fewer bugs
- Discord: Switched from Go to Rust for Read States, reduced latency

Section 3: Rust vs Go — When Performance Matters

Key Points:

Go's philosophy: simplicity over control
- Goroutines and channels are elegant
- GC pauses can be problematic for real-time systems
Rust's approach: zero-cost abstractions
- Async/.await with no runtime overhead
- Fine-grained control over memory layout
When to choose which:
- Go: Fast development, microservices, simple concurrency
- Rust: Maximum performance, systems programming, no GC latency
Industry shift:
- Cloudflare, Discord: Originally Go, adding Rust for performance-critical paths
- Not "Rust vs Go" — more like "Rust AND Go"

Section 4: Rust vs Java — Modern Alternatives to the JVM

Key Points:

Java's strengths:
- Mature ecosystem, excellent tooling
- Write once, run anywhere
Rust's advantages:
- No garbage collection pauses (predictable latency)
- Significantly lower memory usage
- Native binaries, no JVM overhead
Use cases:
- Java: Enterprise applications, Android, large ecosystems
- Rust: Performance-critical systems, WASM, embedded
Interoperability:
- Rust-Java bindings exist (j4rs, hydroflow)
- Can extend Java with native Rust libraries

Section 5: Rust vs Python — When to Make the Jump

Key Points:

Python's appeal:
- Readable, beginner-friendly
- Massive ecosystem (ML, data science, web)
Rust for Python developers:
- PyO3: Python bindings in Rust
- 10-100x performance gains for hot paths -ruff, Polars: Python tools rewritten in Rust
The hybrid approach:
- Write core logic in Rust, wrap in Python
- Example: rich library, lxml alternatives
Learning path:
- Python → Rust is harder than → Go
- But pays off for performance-critical code

Section 6: The Honest Truth — Rust Has a Learning Curve

Key Points:

The borrow checker fights you (at first)
- "fighting the borrow checker" is a rite of passage
- But it catches real bugs
Mentally challenging:
- Ownership takes time to internalize
- Unlike anything in garbage-collected languages
Worth it:
- Once you "get it," you write safer code instinctively
- The compiler becomes your ally, not adversary
Resources:
- Official Book (rust-lang.org/book)
- Rustlings exercises
- exercism.io/rust track

Section 7: Who's Using Rust (And Why)

Companies and Projects:

Microsoft: Windows components, Azure
Google: Android OS, Chrome (parts)
Cloudflare: Edge computing, network services
Amazon: AWS Firecracker VM, S3, EC2
Discord: Read States, Elixir NIFs
Figma: Server-side rendering
Linux: Kernel support (6.1+)
Firefox: CSS engine, JavaScript engine components

Why they chose Rust:

Performance + safety combo
No runtime, deploy anywhere
Modern tooling (cargo, crates.io)

Conclusion

Summary:

Rust offers memory safety WITHOUT garbage collection
Matches C++ performance, with dramatically fewer bugs
Not a replacement for all languages, but the right tool for many jobs
Honest about the learning curve—but worth it

Call to Action:

Try Rust in your browser: rust-lang.org/tools/install
Start with Rustlings for hands-on practice
Pick a small project (CLI tool, HTTP server)
Join the community: r/rust, Discord, Zulip

Final Thought:

"The best time to learn Rust was 5 years ago. The second best time is today."

Full-Stack Development in 2026

Cyrus Tse — Wed, 07 Jan 2026 14:20:22 +0000

The Role

Full-stack developers remain valuable because small teams need generalists, and large companies need people who understand the whole system
T-shaped model: broad shallow knowledge across the stack + deep expertise in 1-2 areas
Not about knowing every framework—it's about being competent enough to ship features end-to-end

Core Fundamentals

HTTP, browser behavior, data structures—these don't change and compound over time
TypeScript is essential in 2026
Don't skip HTML/CSS accessibility basics

Frontend

React still dominates but concepts transfer across frameworks
State management: start simple (useState/useContext), add Redux/Zustand only when needed
Accessibility isn't optional—~15% of users have disabilities
Test behavior, not implementation details

Backend

Node.js/TypeScript or Python/Go are solid choices
APIs: default to REST, consider GraphQL for complex frontend needs, gRPC for services
Authentication: short-lived JWT access tokens + httpOnly refresh tokens
Never roll your own crypto—use auth providers when possible

Databases

Default to PostgreSQL for most applications
Data modeling is a skill that takes time—plan your schema carefully
Use ORMs (Prisma recommended) but understand the SQL being generated
Watch for N+1 query problems and missing indexes

Security

Validate all input server-side
Use parameterized queries to prevent SQL injection
Rate limiting, security headers, proper CORS configuration
Never commit secrets to version control

DevOps

Start simple: Vercel/Render for hosting, GitHub Actions for CI/CD
Docker for containerization
Monitor: error rates, response times, logs
Infrastructure as Code (Terraform/CDK)
Don't start with Kubernetes—you likely don't need it yet