Các khái niệm cốt lõi của Spring Boot — Dependency Injection & Auto-Configuration

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

public class OrderService {

    // Bạn tự tạo các dependency
    private EmailService emailService = new EmailService();
    private OrderRepository orderRepository = new OrderRepository();
    private PaymentGateway paymentGateway = new StripePaymentGateway();

    public void placeOrder(Order order) {
        orderRepository.save(order);
        paymentGateway.charge(order.getTotal());
        emailService.sendConfirmation(order);
    }
}

// Bạn phải thay đổi OrderService chỉ vì muốn dùng nhà cung cấp thanh toán khác
private PaymentGateway paymentGateway = new PayPalPaymentGateway();

// Bạn muốn test placeOrder(), nhưng nó sẽ:
// - Cố kết nối đến cơ sở dữ liệu thật (OrderRepository)
// - Cố tính phí thẻ tín dụng thật (StripePaymentGateway)
// - Cố gửi email thật (EmailService)
// Điều này làm việc kiểm thử chậm, không đáng tin cậy, và có thể tốn kém!

public class OrderService {

    // Các dependency được khai báo, nhưng KHÔNG được tạo ở đây
    private final EmailService emailService;
    private final OrderRepository orderRepository;
    private final PaymentGateway paymentGateway;

    // Các dependency được cung cấp từ bên ngoài thông qua constructor
    public OrderService(EmailService emailService,
                        OrderRepository orderRepository,
                        PaymentGateway paymentGateway) {
        this.emailService = emailService;
        this.orderRepository = orderRepository;
        this.paymentGateway = paymentGateway;
    }

    public void placeOrder(Order order) {
        orderRepository.save(order);
        paymentGateway.charge(order.getTotal());
        emailService.sendConfirmation(order);
    }
}

@Service
public class OrderService {

    private final EmailService emailService;
    private final OrderRepository orderRepository;

    // Spring thấy constructor này, tìm bean kiểu EmailService
    // và OrderRepository trong Application Context, và truyền chúng vào.
    public OrderService(EmailService emailService, 
                        OrderRepository orderRepository) {
        this.emailService = emailService;
        this.orderRepository = orderRepository;
    }

    public void placeOrder(Order order) {
        orderRepository.save(order);
        emailService.sendConfirmation(order);
    }
}

@Service
public class OrderService {

    private EmailService emailService;
    private OrderRepository orderRepository;

    // Spring gọi các setter này sau khi tạo đối tượng
    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }

    @Autowired
    public void setOrderRepository(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
}

@Service
public class OrderService {

    // Spring inject trực tiếp sử dụng reflection —
    // không cần constructor hay setter
    @Autowired
    private EmailService emailService;

    @Autowired
    private OrderRepository orderRepository;
}

@Service  // Điều này cho Spring biết: "Tạo một instance của class này và quản lý nó"
public class UserService {
    // Class này sẽ trở thành một bean trong Application Context
}

1. Tìm thấy định nghĩa Bean (quét @Component)
       ↓
2. Bean được khởi tạo (constructor được gọi)
       ↓
3. Dependency được inject (qua constructor, setter, hoặc field)
       ↓
4. Phương thức @PostConstruct được gọi (nếu có)
       ↓
5. Bean sẵn sàng sử dụng
       ↓
   ... ứng dụng chạy ...
       ↓
6. Phương thức @PreDestroy được gọi (nếu có — khi ứng dụng tắt)
       ↓
7. Bean bị hủy

@Service
public class CacheService {

    private Map<String, Object> cache;

    // Được gọi sau khi bean được tạo và dependency được inject.
    // Sử dụng cho logic khởi tạo cần dependency.
    @PostConstruct
    public void init() {
        System.out.println("CacheService đã khởi tạo!");
        cache = new HashMap<>();
        // Tải dữ liệu ban đầu, khởi động cache, v.v.
    }

    // Được gọi khi ứng dụng đang tắt.
    // Sử dụng cho dọn dẹp: đóng kết nối, flush buffer, v.v.
    @PreDestroy
    public void cleanup() {
        System.out.println("CacheService đang tắt!");
        cache.clear();
    }
}

@Service
public class UserService {
    // Chỉ có MỘT instance của UserService trong toàn bộ ứng dụng.
    // Mọi class phụ thuộc vào UserService đều nhận CÙNG instance.
}

// Singleton (mặc định) — một instance cho toàn bộ ứng dụng
@Scope("singleton")

// Prototype — instance mới mỗi khi ai đó yêu cầu bean này
@Scope("prototype")

// Request — một instance cho mỗi HTTP request (chỉ ứng dụng web)
@Scope("request")

// Session — một instance cho mỗi HTTP session (chỉ ứng dụng web)
@Scope("session")

@Component
public class EmailValidator {
    
    public boolean isValid(String email) {
        return email != null && email.contains("@");
    }
}

@Service
public class UserService {

    private final UserRepository userRepository;

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

    public User createUser(String name, String email) {
        // Kiểm tra đầu vào
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Tên không được để trống");
        }
        // Logic nghiệp vụ ở đây
        User user = new User(name, email);
        return userRepository.save(user);
    }
}

@Repository
public class UserRepository {

    // Trong các bài sau, chúng ta sẽ sử dụng Spring Data JPA và
    // không phải viết implementation repository thủ công. Hiện tại,
    // chúng ta dùng danh sách trong bộ nhớ để mô phỏng thao tác database.
    private final List<User> users = new ArrayList<>();
    private long nextId = 1;

    public User save(User user) {
        user.setId(nextId++);
        users.add(user);
        return user;
    }

    public Optional<User> findById(Long id) {
        return users.stream()
                .filter(u -> u.getId().equals(id))
                .findFirst();
    }

    public List<User> findAll() {
        return Collections.unmodifiableList(users);
    }
}

@RestController
public class UserController {

    private final UserService userService;

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

    @GetMapping("/api/users")
    public List<User> getAllUsers() {
        return userService.findAllUsers();
    }
}

HTTP Request
     ↓
@RestController  (Tầng Web — xử lý HTTP, ủy quyền cho service)
     ↓
@Service         (Tầng Service — logic nghiệp vụ, validation, điều phối)
     ↓
@Repository      (Tầng Truy cập dữ liệu — thao tác database)
     ↓
Database

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component  // <-- @Service CHÍNH LÀ @Component
public @interface Service {
    String value() default "";
}

@Service
public class NotificationService {

    @Autowired  // Spring tìm bean kiểu EmailService và inject
    private EmailService emailService;
}

@Service
public class NotificationService {

    private final EmailService emailService;
    private final SmsService smsService;

    // Chỉ một constructor → Spring tự động sử dụng cho DI.
    // Không cần @Autowired!
    public NotificationService(EmailService emailService, 
                                SmsService smsService) {
        this.emailService = emailService;
        this.smsService = smsService;
    }
}

@Service
public class NotificationService {

    private final EmailService emailService;
    private final SmsService smsService;

    @Autowired  // Bắt buộc vì có nhiều constructor
    public NotificationService(EmailService emailService, 
                                SmsService smsService) {
        this.emailService = emailService;
        this.smsService = smsService;
    }

    // Constructor thứ hai — Spring SẼ KHÔNG sử dụng cái này
    public NotificationService(EmailService emailService) {
        this(emailService, null);
    }
}

@Service
public class OrderService {

    @Autowired
    private PaymentGateway paymentGateway;

    @Autowired
    private EmailService emailService;

    public void placeOrder(Order order) {
        paymentGateway.charge(order.getTotal());
        emailService.sendConfirmation(order);
    }
}

// Không có Spring, bạn KHÔNG THỂ tạo đối tượng này với dependency
OrderService service = new OrderService();
// service.paymentGateway là null!
// service.emailService là null!
// service.placeOrder(order) → NullPointerException!

@Service
public class OrderService {

    private final PaymentGateway paymentGateway;
    private final EmailService emailService;

    public OrderService(PaymentGateway paymentGateway, 
                        EmailService emailService) {
        this.paymentGateway = paymentGateway;
        this.emailService = emailService;
    }

    public void placeOrder(Order order) {
        paymentGateway.charge(order.getTotal());
        emailService.sendConfirmation(order);
    }
}

// Tạo mock implementation
PaymentGateway mockPayment = new FakePaymentGateway();
EmailService mockEmail = new FakeEmailService();

// Tạo service với dependency — chỉ là Java thuần!
OrderService service = new OrderService(mockPayment, mockEmail);

// Test
service.placeOrder(testOrder);
// Xác minh mockPayment đã tính phí, mockEmail đã gửi, v.v.

***************************
APPLICATION FAILED TO START
***************************

Description:
Parameter 0 of constructor in com.example.OrderService 
required a bean of type 'com.example.PaymentGateway' 
that could not be found.

Action:
Consider defining a bean of type 'com.example.PaymentGateway' 
in your configuration.

public interface PaymentGateway {
    void charge(double amount);
}

@Component
public class StripePaymentGateway implements PaymentGateway {
    public void charge(double amount) { /* Logic Stripe */ }
}

@Component
public class PayPalPaymentGateway implements PaymentGateway {
    public void charge(double amount) { /* Logic PayPal */ }
}

@Service
public class OrderService {
    // Spring tìm thấy HAI bean kiểu PaymentGateway — inject cái nào?
    public OrderService(PaymentGateway paymentGateway) { ... }
}

@Component
@Primary  // Cái này sẽ được inject khi có nhiều ứng viên
public class StripePaymentGateway implements PaymentGateway { ... }

@Service
public class OrderService {
    public OrderService(
            @Qualifier("payPalPaymentGateway") PaymentGateway paymentGateway) {
        // Spring sẽ inject PayPalPaymentGateway cụ thể
    }
}

@Service
public class OrderService {
    // Tên tham số "stripePaymentGateway" khớp với tên bean
    public OrderService(PaymentGateway stripePaymentGateway) { ... }
}

NẾU class "DataSource" có trên classpath
VÀ property "spring.datasource.url" được cấu hình
VÀ chưa có bean kiểu DataSource
THÌ tạo bean DataSource tự động

// Chỉ kích hoạt nếu class HikariDataSource có trên classpath
@ConditionalOnClass(HikariDataSource.class)

// Chỉ kích hoạt nếu chưa có bean kiểu DataSource
@ConditionalOnMissingBean(DataSource.class)

// Chỉ kích hoạt nếu property được thiết lập
@ConditionalOnProperty(name = "spring.datasource.url")

# Hiển thị auto-configuration nào được áp dụng và bỏ qua
debug=true

============================
CONDITIONS EVALUATION REPORT
============================

Positive matches:  (cấu hình ĐÃ được áp dụng)
-----------------
   JacksonAutoConfiguration matched:
      - @ConditionalOnClass found required class 'com.fasterxml.jackson.databind.ObjectMapper'

   WebMvcAutoConfiguration matched:
      - @ConditionalOnClass found required class 'jakarta.servlet.Servlet'

Negative matches:  (cấu hình ĐÃ BỊ BỎ QUA)
-----------------
   DataSourceAutoConfiguration:
      - @ConditionalOnClass did not find required class 'javax.sql.DataSource'

# Cấu hình server
server.port=8080
server.servlet.context-path=/api

# Cấu hình database (chúng ta sẽ dùng trong Bài 5)
spring.datasource.url=jdbc:mariadb://localhost:3306/blogdb
spring.datasource.username=root
spring.datasource.password=secret

# Cấu hình JPA
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

# Logging
logging.level.root=INFO
logging.level.com.example.blogapi=DEBUG

# Cấu hình server
server:
  port: 8080
  servlet:
    context-path: /api

# Cấu hình database
spring:
  datasource:
    url: jdbc:mariadb://localhost:3306/blogdb
    username: root
    password: secret
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true

# Logging
logging:
  level:
    root: INFO
    com.example.blogapi: DEBUG

# Property tùy chỉnh
blog.app.name=My Blog API
blog.app.version=1.0.0
blog.app.max-posts-per-page=20

@Service
public class AppInfoService {

    // @Value inject giá trị property từ application.properties.
    // Cú pháp ${property.name} tham chiếu một key property.
    // Phần sau ":" là giá trị mặc định nếu property không tìm thấy.
    @Value("${blog.app.name:Default Blog}")
    private String appName;

    @Value("${blog.app.version:0.0.1}")
    private String appVersion;

    @Value("${blog.app.max-posts-per-page:10}")
    private int maxPostsPerPage;

    public String getAppInfo() {
        return appName + " v" + appVersion;
    }
}

@Component
@ConfigurationProperties(prefix = "blog.app")
public class BlogProperties {

    // Spring ánh xạ blog.app.name → name, blog.app.version → version, v.v.
    // Tên trường phải khớp với tên property (sau tiền tố).
    private String name;
    private String version;
    private int maxPostsPerPage;

    // Getter và setter bắt buộc cho @ConfigurationProperties
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getVersion() { return version; }
    public void setVersion(String version) { this.version = version; }

    public int getMaxPostsPerPage() { return maxPostsPerPage; }
    public void setMaxPostsPerPage(int maxPostsPerPage) { 
        this.maxPostsPerPage = maxPostsPerPage; 
    }
}

@Service
public class PostService {

    private final BlogProperties blogProperties;

    public PostService(BlogProperties blogProperties) {
        this.blogProperties = blogProperties;
    }

    public int getPageSize() {
        return blogProperties.getMaxPostsPerPage();
    }
}

src/main/resources/
├── application.properties          ← Luôn được tải (thiết lập chung)
├── application-dev.properties      ← Tải khi profile "dev" được kích hoạt
├── application-test.properties     ← Tải khi profile "test" được kích hoạt
└── application-prod.properties     ← Tải khi profile "prod" được kích hoạt

# Thiết lập chia sẻ giữa tất cả môi trường
blog.app.name=My Blog API
server.servlet.context-path=/api

# Thiết lập đặc thù cho development
server.port=8080
logging.level.root=DEBUG
logging.level.com.example.blogapi=TRACE
spring.datasource.url=jdbc:mariadb://localhost:3306/blog_dev
spring.datasource.username=root
spring.datasource.password=devpassword
spring.jpa.show-sql=true

# Thiết lập đặc thù cho production
server.port=80
logging.level.root=WARN
logging.level.com.example.blogapi=INFO
spring.datasource.url=jdbc:mariadb://prod-db-server:3306/blog_prod
spring.datasource.username=blog_app
spring.datasource.password=${DB_PASSWORD}
spring.jpa.show-sql=false

# Thiết lập profile active mặc định
spring.profiles.active=dev

java -jar blog-api.jar --spring.profiles.active=prod

export SPRING_PROFILES_ACTIVE=prod
java -jar blog-api.jar

@Service
@Profile("dev")
public class FakeEmailService implements EmailService {
    
    // Trong development, chỉ in ra console thay vì gửi email thật
    @Override
    public void sendEmail(String to, String subject, String body) {
        System.out.println("=== EMAIL GIẢ ===");
        System.out.println("Đến: " + to);
        System.out.println("Tiêu đề: " + subject);
        System.out.println("Nội dung: " + body);
        System.out.println("=================");
    }
}

@Service
@Profile("prod")
public class SmtpEmailService implements EmailService {

    // Trong production, gửi email thật qua SMTP
    @Override
    public void sendEmail(String to, String subject, String body) {
        // Logic gửi email SMTP thật
    }
}

package com.example.blogapi.model;

// Đây là class Java đơn giản (POJO — Plain Old Java Object).
// Nó đại diện cho một người dùng trong ứng dụng.
// Trong các bài sau, chúng ta sẽ thêm annotation JPA để ánh xạ nó đến bảng database.
public class User {

    private Long id;
    private String name;
    private String email;

    // Constructor mặc định — bắt buộc cho Jackson deserialization.
    // Khi client gửi dữ liệu JSON, Jackson cần constructor này để tạo đối tượng User.
    public User() {
    }

    // Constructor có tham số — tiện lợi cho việc tạo đối tượng User trong code.
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getter và setter — bắt buộc để Jackson chuyển đổi giữa
    // đối tượng Java và JSON. Jackson đọc getter cho serialization
    // (Java → JSON) và dùng setter cho deserialization (JSON → Java).

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

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

    // toString() hữu ích cho logging và debug
    @Override
    public String toString() {
        return "User{id=" + id + ", name='" + name + "', email='" + email + "'}";
    }
}

package com.example.blogapi.repository;

import com.example.blogapi.model.User;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;

// @Repository đánh dấu đây là component truy cập dữ liệu.
// Spring sẽ tạo một singleton instance và quản lý nó.
// Hiện tại, chúng ta dùng List trong bộ nhớ để mô phỏng database.
// Trong Bài 5, chúng ta sẽ thay thế bằng Spring Data JPA + MariaDB.
@Repository
public class UserRepository {

    // Database mô phỏng — danh sách đơn giản lưu trong bộ nhớ.
    // CẢNH BÁO: Dữ liệu sẽ mất khi ứng dụng khởi động lại!
    // Database thật giải quyết vấn đề này. Chúng ta sẽ thêm MariaDB ở Bài 5.
    private final List<User> users = new ArrayList<>();

    // Bộ đếm ID tự tăng, mô phỏng sequence của database
    private long nextId = 1;

    // Lưu người dùng — tương tự SQL INSERT
    public User save(User user) {
        user.setId(nextId++);
        users.add(user);
        return user;
    }

    // Tìm người dùng theo ID — tương tự SQL SELECT WHERE id = ?
    // Trả về Optional vì người dùng có thể không tồn tại.
    // Optional buộc người gọi phải xử lý trường hợp "không tìm thấy" một cách rõ ràng.
    public Optional<User> findById(Long id) {
        return users.stream()
                .filter(user -> user.getId().equals(id))
                .findFirst();
    }

    // Tìm tất cả người dùng — tương tự SQL SELECT *
    // Trả về danh sách không thể sửa đổi để ngăn code bên ngoài
    // vô tình sửa "database" của chúng ta
    public List<User> findAll() {
        return Collections.unmodifiableList(users);
    }

    // Xóa người dùng theo ID — tương tự SQL DELETE WHERE id = ?
    // Trả về true nếu tìm và xóa được, false nếu không
    public boolean deleteById(Long id) {
        return users.removeIf(user -> user.getId().equals(id));
    }

    // Đếm tổng người dùng — tương tự SQL SELECT COUNT(*)
    public long count() {
        return users.size();
    }
}

package com.example.blogapi.service;

import com.example.blogapi.model.User;
import com.example.blogapi.repository.UserRepository;
import org.springframework.stereotype.Service;

import java.util.List;

// @Service đánh dấu class này là component logic nghiệp vụ.
// Nó nằm giữa Controller (tầng HTTP) và Repository (tầng dữ liệu).
// Tất cả quy tắc nghiệp vụ, validation, và logic điều phối nằm ở đây.
@Service
public class UserService {

    // Dependency khai báo là trường final — không thể thay đổi sau khi khởi tạo
    private final UserRepository userRepository;

    // Constructor injection — Spring thấy constructor này, tìm bean kiểu
    // UserRepository trong Application Context, và truyền vào.
    // Vì đây là constructor DUY NHẤT, không cần @Autowired.
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // Phương thức nghiệp vụ: Tạo người dùng mới với validation
    public User createUser(String name, String email) {

        // Quy tắc nghiệp vụ: tên không được rỗng
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("Tên người dùng không được để trống");
        }

        // Quy tắc nghiệp vụ: email phải chứa @
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Địa chỉ email không hợp lệ: " + email);
        }

        // Quy tắc nghiệp vụ: cắt khoảng trắng từ tên
        name = name.trim();

        // Tạo người dùng và ủy quyền cho repository để lưu trữ
        User user = new User(name, email.trim().toLowerCase());
        return userRepository.save(user);
    }

    // Phương thức nghiệp vụ: Lấy người dùng theo ID
    // Ném exception nếu không tìm thấy — controller sẽ xử lý
    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException(
                        "Không tìm thấy người dùng với id: " + id));
    }

    // Phương thức nghiệp vụ: Lấy tất cả người dùng
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    // Phương thức nghiệp vụ: Xóa người dùng
    public void deleteUser(Long id) {
        boolean deleted = userRepository.deleteById(id);
        if (!deleted) {
            throw new RuntimeException("Không tìm thấy người dùng với id: " + id);
        }
    }

    // Phương thức nghiệp vụ: Đếm số người dùng
    public long getUserCount() {
        return userRepository.count();
    }
}

package com.example.blogapi.controller;

import com.example.blogapi.model.User;
import com.example.blogapi.service.UserService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

// @RestController = @Controller + @ResponseBody
// Mọi phương thức trả về dữ liệu (JSON), không phải view (template HTML)
@RestController
@RequestMapping("/api/users")  // Đường dẫn gốc — tất cả endpoint trong controller này bắt đầu với /api/users
public class UserController {

    private final UserService userService;

    // Constructor injection — Spring inject bean UserService
    public UserController(UserService userService) {
        this.userService = userService;
    }

    // GET /api/users — Lấy tất cả người dùng
    @GetMapping
    public List<User> getAllUsers() {
        // Controller chỉ đơn giản ủy quyền cho service.
        // Không có logic nghiệp vụ ở đây — đó thuộc về tầng service.
        return userService.getAllUsers();
    }

    // GET /api/users/{id} — Lấy một người dùng cụ thể
    // @PathVariable trích xuất {id} từ đường dẫn URL.
    // Ví dụ: GET /api/users/42 → id = 42
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    // POST /api/users — Tạo người dùng mới
    // @RequestBody yêu cầu Spring phân tích phần thân HTTP request (JSON)
    // và chuyển đổi thành đối tượng Map.
    //
    // ResponseEntity cho chúng ta quyền kiểm soát mã trạng thái HTTP.
    // Chúng ta trả về 201 (Created) thay vì 200 (OK) vì tài nguyên mới đã được tạo.
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody Map<String, String> request) {
        String name = request.get("name");
        String email = request.get("email");
        User createdUser = userService.createUser(name, email);

        // Trả về người dùng đã tạo với trạng thái HTTP 201
        return new ResponseEntity<>(createdUser, HttpStatus.CREATED);
    }

    // DELETE /api/users/{id} — Xóa người dùng
    // Trả về thông báo xác nhận thay vì người dùng đã xóa
    @DeleteMapping("/{id}")
    public Map<String, String> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        Map<String, String> response = new HashMap<>();
        response.put("message", "Xóa người dùng thành công");
        response.put("deletedId", id.toString());
        return response;
    }

    // GET /api/users/count — Đếm tổng số người dùng
    @GetMapping("/count")
    public Map<String, Long> getUserCount() {
        Map<String, Long> response = new HashMap<>();
        response.put("count", userService.getUserCount());
        return response;
    }
}

1. Spring quét package và tìm thấy:
   - UserRepository  (@Repository)
   - UserService     (@Service) — cần UserRepository
   - UserController  (@RestController) — cần UserService

2. Spring tạo bean theo thứ tự dependency:
   a) UserRepository được tạo trước (không có dependency)
   b) UserService được tạo, nhận UserRepository qua constructor
   c) UserController được tạo, nhận UserService qua constructor

3. Luồng HTTP request:
   
   Client gửi: POST /api/users {"name":"Alice","email":"alice@example.com"}
        ↓
   UserController.createUser() — trích xuất name và email từ JSON
        ↓
   UserService.createUser() — validate đầu vào, tạo đối tượng User
        ↓
   UserRepository.save() — lưu người dùng, gán ID
        ↓
   Response đi ngược lên: User{id=1, name="Alice", email="alice@example.com"}
        ↓
   Client nhận: HTTP 201 {"id":1,"name":"Alice","email":"alice@example.com"}

# Tạo người dùng
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice", "email": "alice@example.com"}'

# Kết quả mong đợi (HTTP 201):
# {"id":1,"name":"Alice","email":"alice@example.com"}

# Tạo người dùng khác
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"name": "Bob", "email": "bob@example.com"}'

# Kết quả mong đợi (HTTP 201):
# {"id":2,"name":"Bob","email":"bob@example.com"}

# Lấy tất cả người dùng
curl http://localhost:8080/api/users

# Kết quả mong đợi:
# [{"id":1,"name":"Alice","email":"alice@example.com"},
#  {"id":2,"name":"Bob","email":"bob@example.com"}]

# Lấy người dùng cụ thể
curl http://localhost:8080/api/users/1

# Kết quả mong đợi:
# {"id":1,"name":"Alice","email":"alice@example.com"}

# Đếm số người dùng
curl http://localhost:8080/api/users/count

# Kết quả mong đợi:
# {"count":2}

# Xóa người dùng
curl -X DELETE http://localhost:8080/api/users/1

# Kết quả mong đợi:
# {"message":"Xóa người dùng thành công","deletedId":"1"}

# Thử tạo người dùng với dữ liệu không hợp lệ
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"name": "", "email": "invalid"}'

# Kết quả mong đợi (HTTP 500 — chúng ta sẽ cải thiện xử lý lỗi ở Bài 8):
# {"timestamp":"...","status":500,"error":"Internal Server Error",...}