Hướng Dẫn Thực Hành Cấu Hình Xác Thực Trong Spring

Chào mừng các bạn trở lại với hành trình “Java Spring Roadmap”! Nếu bạn đã theo dõi series của chúng ta, hẳn bạn đã nắm vững những khái niệm cốt lõi như IoC Container, Dependency Injection, Bean scopes, AOP, và cách xây dựng ứng dụng web cơ bản với Spring MVC. Nếu chưa, đừng lo lắng, hãy ghé thăm các bài viết trước để có nền tảng vững chắc nhé:

Trong bài viết này, chúng ta sẽ tập trung vào một khía cạnh cực kỳ quan trọng của mọi ứng dụng thực tế: Bảo mật. Cụ thể hơn, chúng ta sẽ “xắn tay áo” và tìm hiểu cách cấu hình Xác thực (Authentication) trong Spring Security. Như đã đề cập trong bài Spring Security 101, xác thực là quá trình xác định người dùng là ai. Đây là bước đầu tiên và là nền tảng để triển khai phân quyền (Authorization) – quyết định người dùng đó được làm gì.

Spring Security là một framework bảo mật mạnh mẽ và linh hoạt, được tích hợp sâu với Spring ecosystem. Nó cung cấp giải pháp toàn diện cho cả xác thực và phân quyền. Bắt đầu nào!

Tại sao cần cấu hình Xác thực?

Trong một ứng dụng web hoặc dịch vụ API, không phải lúc nào bạn cũng muốn mọi người đều có thể truy cập mọi tài nguyên. Một số trang, API, hoặc chức năng chỉ dành cho người dùng đã đăng nhập. Xác thực chính là “người gác cổng” đầu tiên, đảm bảo rằng chỉ những người dùng “đã biết” mới được phép đi tiếp vào bên trong hệ thống để thực hiện các hành động được phép.

Việc cấu hình xác thực cho phép ứng dụng của bạn:

  1. Nhận diện người dùng (qua tên đăng nhập/mật khẩu, token, v.v.).
  2. Tạo ra một phiên làm việc hoặc ngữ cảnh bảo mật gắn với người dùng đó.
  3. Sử dụng thông tin người dùng đã xác thực để kiểm tra quyền hạn (authorization) ở các lớp sau.

Spring Security hoạt động với Xác thực như thế nào?

Spring Security hoạt động dựa trên một chuỗi các bộ lọc (Filters) trong Servlet container. Khi một yêu cầu (request) đến, nó sẽ đi qua các bộ lọc này. Một trong những bộ lọc quan trọng nhất liên quan đến xác thực là UsernamePasswordAuthenticationFilter (mặc định cho form login) hoặc các bộ lọc tương ứng khác cho các phương thức xác thực khác (ví dụ: Basic Auth Filter, Bearer Token Filter…).

Quá trình xác thực cơ bản diễn ra như sau:

  1. Yêu cầu (ví dụ: POST đến /login) chứa thông tin đăng nhập (username, password) được gửi đến ứng dụng.
  2. Bộ lọc xác thực tương ứng bắt lấy yêu cầu này.
  3. Bộ lọc tạo ra một đối tượng Authentication (chưa được xác thực – unauthenticated) chứa thông tin đăng nhập.
  4. Đối tượng AuthenticationManager (trái tim của quy trình xác thực) nhận đối tượng Authentication này.
  5. AuthenticationManager ủy quyền việc xác thực cho một hoặc nhiều AuthenticationProvider.
  6. AuthenticationProvider (ví dụ: DaoAuthenticationProvider) sẽ lấy thông tin người dùng dựa trên username (thường thông qua UserDetailsService) và so sánh mật khẩu đã mã hóa (sử dụng PasswordEncoder).
  7. Nếu xác thực thành công, AuthenticationProvider trả về một đối tượng Authentication đã được xác thực (authenticated) chứa thông tin chi tiết của người dùng (UserDetails) và danh sách quyền hạn (Authorities).
  8. AuthenticationManager nhận đối tượng đã xác thực này và đưa vào SecurityContextHolder. SecurityContextHolder là nơi Spring Security lưu trữ thông tin bảo mật của người dùng hiện tại (theo Thread Local theo mặc định, hoặc theo request/session tùy cấu hình).
  9. Yêu cầu được tiếp tục xử lý hoặc bị từ chối nếu xác thực thất bại.

Hiểu luồng này giúp bạn biết các thành phần nào cần cấu hình.

Cài đặt Spring Security

Cách đơn giản nhất để bắt đầu là thêm dependency vào dự án Spring Boot của bạn. Nếu dùng Maven:


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Thêm dependency cho template engine nếu cần (ví dụ: Thymeleaf) -->

Nếu dùng Gradle:


implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.springframework.boot:spring-boot-starter-web'
// implementation 'org.springframework.boot:spring-boot-starter-thymeleaf' // nếu cần

Khi bạn thêm dependency này vào dự án Spring Boot, Spring Security sẽ tự động cấu hình một số thứ mặc định:

  • Bảo vệ mọi endpoint HTTP trừ các tài nguyên tĩnh.
  • Tạo một trang đăng nhập (login page) và đăng xuất (logout endpoint) cơ bản.
  • Tạo một người dùng mặc định với username là “user” và mật khẩu ngẫu nhiên (in ra console khi ứng dụng khởi động).
  • Bật CSRF protection (bảo vệ chống tấn công Cross-Site Request Forgery).

Tuy nhiên, cấu hình mặc định này hiếm khi đủ cho ứng dụng thực tế. Chúng ta cần tùy chỉnh nó.

Cấu hình Xác thực với SecurityFilterChain

Để tùy chỉnh bảo mật, bạn sẽ tạo một lớp cấu hình sử dụng @Configuration và @EnableWebSecurity (với Spring Boot, @EnableWebSecurity thường không bắt buộc vì nó được tự động thêm bởi starter, nhưng thêm vào cũng không hại gì và giúp code rõ ràng hơn). Bên trong lớp này, bạn định nghĩa một Bean kiểu SecurityFilterChain. Đây là cách hiện đại và được khuyến khích để cấu hình bảo mật HTTP trong Spring Security.


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/public/**", "/css/**", "/js/**").permitAll() // Cho phép truy cập công khai
                .requestMatchers("/admin/**").hasRole("ADMIN") // Yêu cầu vai trò ADMIN
                .requestMatchers("/user/**").hasAnyRole("USER", "ADMIN") // Yêu cầu vai trò USER hoặc ADMIN
                .anyRequest().authenticated() // Tất cả các yêu cầu khác đều phải được xác thực
            )
            .formLogin(form -> form
                .loginPage("/login") // Chỉ định URL trang đăng nhập tùy chỉnh
                .defaultSuccessUrl("/") // URL chuyển hướng sau khi đăng nhập thành công
                .permitAll() // Cho phép mọi người truy cập trang đăng nhập
            )
            .logout(logout -> logout
                .logoutUrl("/logout") // Chỉ định URL đăng xuất
                .logoutSuccessUrl("/login?logout") // URL chuyển hướng sau khi đăng xuất thành công
                .permitAll() // Cho phép mọi người truy xuất URL đăng xuất
            )
            .csrf(csrf -> csrf.disable()); // Tắt CSRF cho đơn giản trong ví dụ này (cẩn trọng khi dùng trong thực tế)

        return http.build();
    }

    // ... Định nghĩa UserDetailsManager/UserDetailsService và PasswordEncoder beans ở đây ...
}

Trong ví dụ trên, chúng ta sử dụng đối tượng HttpSecurity để cấu hình:

  • authorizeHttpRequests(): Bắt đầu cấu hình các quy tắc cho các yêu cầu HTTP.
  • requestMatchers(): Chỉ định các đường dẫn (URL patterns) áp dụng quy tắc.
  • permitAll(): Cho phép truy cập mà không cần xác thực.
  • authenticated(): Yêu cầu người dùng phải được xác thực.
  • hasRole(), hasAnyRole(): Yêu cầu người dùng phải có vai trò (role) cụ thể. Đây là về Phân quyền, nhưng thường được cấu hình cùng lúc với Xác thực.
  • anyRequest(): Áp dụng cho bất kỳ yêu cầu nào chưa được khớp với requestMatchers trước đó.
  • formLogin(): Bật cấu hình xác thực dựa trên form HTML.
  • loginPage(): Chỉ định URL của trang đăng nhập tùy chỉnh của bạn.
  • defaultSuccessUrl(): Chỉ định URL mặc định sau khi đăng nhập thành công.
  • logout(): Bật cấu hình đăng xuất.
  • logoutUrl(): Chỉ định URL để kích hoạt quá trình đăng xuất (thường là POST đến /logout).
  • logoutSuccessUrl(): Chỉ định URL sau khi đăng xuất thành công.
  • csrf().disable(): Vô hiệu hóa bảo vệ CSRF. Hãy cẩn trọng khi làm điều này trong ứng dụng thực tế, đặc biệt là các ứng dụng web. Nó thường được bật cho các ứng dụng web truyền thống và có thể vô hiệu hóa cho các API stateless (như REST API dùng JWT).

Nguồn dữ liệu Người dùng: UserDetailsService và UserDetails

Sau khi cấu hình SecurityFilterChain để xác định đường dẫn nào cần bảo vệ, bạn cần cho Spring Security biết thông tin về người dùng của bạn ở đâu và làm thế nào để kiểm tra mật khẩu. Đây là vai trò của UserDetailsService và PasswordEncoder.

UserDetailsService

UserDetailsService là một interface đơn giản với một phương thức duy nhất: loadUserByUsername(String username). Phương thức này chịu trách nhiệm lấy thông tin chi tiết của người dùng (dưới dạng đối tượng UserDetails) dựa trên tên đăng nhập được cung cấp.

Spring Security sẽ tự động tìm kiếm một Bean kiểu UserDetailsService và sử dụng nó trong quá trình xác thực.

Bạn có thể triển khai UserDetailsService để lấy thông tin người dùng từ nhiều nguồn khác nhau:

  1. In-Memory Authentication: Lưu trữ người dùng trong bộ nhớ. Chỉ dùng cho mục đích phát triển hoặc thử nghiệm đơn giản. Sử dụng InMemoryUserDetailsManager.
  2. Database Authentication: Lấy người dùng từ cơ sở dữ liệu (JDBC hoặc JPA). Đây là cách phổ biến nhất. Bạn sẽ triển khai UserDetailsService hoặc sử dụng các lớp hỗ trợ sẵn có của Spring Security.
  3. LDAP Authentication: Lấy người dùng từ máy chủ LDAP.
  4. Custom Authentication: Lấy người dùng từ bất kỳ nguồn nào khác (file, dịch vụ bên ngoài, v.v.) bằng cách triển khai UserDetailsService của riêng bạn.

Ví dụ: Cấu hình In-Memory UserDetailsManager (Chỉ dùng cho Dev/Test!)

Bạn thêm Bean này vào lớp SecurityConfig:


// ... imports ...
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    // ... securityFilterChain Bean ...

    @Bean
    public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {
        // Sử dụng builder pattern để tạo UserDetails
        UserDetails user = User.withUsername("user")
            .password(passwordEncoder.encode("password")) // Mật khẩu phải được mã hóa!
            .roles("USER")
            .build();

        UserDetails admin = User.withUsername("admin")
            .password(passwordEncoder.encode("adminpass")) // Mật khẩu phải được mã hóa!
            .roles("ADMIN", "USER") // Một người dùng có thể có nhiều vai trò
            .build();

        // Trả về InMemoryUserDetailsManager với danh sách người dùng
        return new InMemoryUserDetailsManager(user, admin);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
         // Sử dụng PasswordEncoderFactories.createDelegatingPasswordEncoder()
         // Đây là cách được khuyến nghị từ Spring Security 5.0+
         // Nó hỗ trợ nhiều thuật toán mã hóa và tự động chọn thuật toán mới nhất
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
}

Lưu ý quan trọng:
* Chúng ta inject PasswordEncoder vào phương thức userDetailsService. Spring sẽ tự động cung cấp Bean PasswordEncoder mà chúng ta đã định nghĩa.
* Mật khẩu phải được mã hóa trước khi lưu trữ và so sánh. User.withUsername("user").password("password")... sử dụng PasswordEncoder mặc định (DelegatingPasswordEncoder) nếu bạn cung cấp bean PasswordEncoder. Tuy nhiên, tốt nhất là gọi passwordEncoder.encode() một cách rõ ràng để hiểu rõ luồng hoạt động.
* Không bao giờ sử dụng User.withDefaultPasswordEncoder() trong môi trường Production! Phương thức này sử dụng mã hóa văn bản thuần (plaintext) hoặc các thuật toán yếu, cực kỳ nguy hiểm.

Ví dụ: Cấu hình Database Authentication với Custom UserDetailsService

Đầu tiên, bạn cần có lớp triển khai UserDetailsService của riêng mình. Giả sử bạn có một Entity UserEntity và một Repository UserRepository:


import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User; // Sử dụng User của Spring Security

import java.util.stream.Collectors;

// Cần inject UserRepository của bạn
// @Autowired
// private UserRepository userRepository;

@Service // Đánh dấu đây là một Spring Bean
public class CustomUserDetailsService implements UserDetailsService {

    // Giả định có một method để lấy user từ database
    // Thay thế bằng logic truy vấn DB thực tế của bạn
    private UserEntity findUserInDatabase(String username) {
        // Ví dụ dummy:
        if ("testuser".equals(username)) {
            UserEntity user = new UserEntity();
            user.setUsername("testuser");
            // Mật khẩu đã mã hóa cho "password"
            user.setPassword("$2a$10$SlYQmygluckgezY/N0qXlOTz.0w0T3Fm5d3M/hM8N5eJm.V1M/pA2");
            user.setRoles(Set.of("USER")); // Set of roles
            return user;
        }
        return null;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // Lấy thông tin người dùng từ database hoặc nguồn dữ liệu khác
        // UserEntity userEntity = userRepository.findByUsername(username)
        //    .orElseThrow(() -> new UsernameNotFoundException("User not found with username: " + username));

        // --- Thay thế bằng logic lấy user thực tế ---
        UserEntity userEntity = findUserInDatabase(username);
        if (userEntity == null) {
             throw new UsernameNotFoundException("User not found with username: " + username);
        }
        // --- Kết thúc logic lấy user thực tế ---

        // Chuyển đổi thông tin từ UserEntity sang UserDetails của Spring Security
        return User.builder()
            .username(userEntity.getUsername())
            .password(userEntity.getPassword()) // Mật khẩu đã mã hóa
            .authorities(userEntity.getRoles().stream()
                         .map(role -> new SimpleGrantedAuthority("ROLE_" + role)) // Thêm tiền tố "ROLE_" theo quy ước
                         .collect(Collectors.toList()))
            .build();
    }
}

// Giả định UserEntity (có thể là JPA Entity)
// import jakarta.persistence.*; // hoặc javax.persistence
// import java.util.Set;

// @Entity
// @Table(name = "users")
class UserEntity { // Đổi thành class thực tế của bạn và thêm các annotations cần thiết
    private Long id;
    private String username;
    private String password; // Mật khẩu đã mã hóa
    private Set<String> roles; // Ví dụ: {"USER", "ADMIN"}

    // 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 getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public Set<String> getRoles() { return roles; }
    public void setRoles(Set<String> roles) { this.roles = roles; }
}

Khi bạn đánh dấu lớp CustomUserDetailsService bằng @Service, Spring sẽ tự động tạo Bean cho nó. Spring Security sẽ tìm thấy Bean UserDetailsService này và sử dụng nó.

Bạn vẫn cần định nghĩa Bean PasswordEncoder như trong ví dụ trước:


    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }

DaoAuthenticationProvider mặc định của Spring Security sẽ tự động sử dụng Bean UserDetailsService và PasswordEncoder mà bạn cung cấp để thực hiện xác thực.

Mã hóa Mật khẩu với PasswordEncoder

Như đã nhấn mạnh, việc mã hóa mật khẩu là cực kỳ quan trọng. Không bao giờ lưu trữ mật khẩu dưới dạng văn bản thuần trong cơ sở dữ liệu. PasswordEncoder là interface mà Spring Security sử dụng để mã hóa mật khẩu mới và so sánh mật khẩu đã lưu trữ với mật khẩu do người dùng nhập vào.

Implementations phổ biến nhất là BCryptPasswordEncoder. Nó sử dụng thuật toán bCrypt, một thuật toán mã hóa một chiều (hash) mạnh mẽ và tích hợp “salt” (chuỗi ngẫu nhiên) vào quá trình mã hóa, giúp chống lại các cuộc tấn công rainbow table.

Kể từ Spring Security 5.0, cách khuyến nghị là sử dụng PasswordEncoderFactories.createDelegatingPasswordEncoder(). Nó tạo ra một DelegatingPasswordEncoder, cho phép bạn cấu hình nhiều thuật toán mã hóa khác nhau và chỉ định thuật toán mặc định. Định dạng mật khẩu sẽ bắt đầu bằng tiền tố như {bcrypt}, {noop} (không mã hóa – chỉ cho test!), {pbkdf2}, v.v. Điều này cho phép bạn dễ dàng chuyển đổi sang thuật toán mạnh hơn trong tương lai mà không cần mã hóa lại toàn bộ mật khẩu cũ cùng lúc.

Bạn cần định nghĩa một Bean PasswordEncoder trong lớp cấu hình bảo mật của mình:


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
// ... các imports khác ...

@Configuration
// @EnableWebSecurity // Có thể bỏ qua với Spring Boot Starter
public class SecurityConfig {

    // ... securityFilterChain Bean ...
    // ... userDetailsService Bean (nếu cần tùy chỉnh) ...

    @Bean
    public PasswordEncoder passwordEncoder() {
        // Sử dụng DelegatingPasswordEncoder được khuyến nghị
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();

        // Hoặc sử dụng trực tiếp BCryptPasswordEncoder nếu bạn chỉ muốn dùng BCrypt
        // return new BCryptPasswordEncoder();
    }
}

Khi bạn cung cấp Bean PasswordEncoder, Spring Security sẽ tự động sử dụng nó khi cần xác thực mật khẩu.

Ví dụ Tùy chỉnh Trang Đăng nhập và Đăng xuất

Mặc định, Spring Security cung cấp một trang đăng nhập và đăng xuất đơn giản. Tuy nhiên, trong ứng dụng thực tế, bạn sẽ muốn sử dụng trang của riêng mình. Bạn đã thấy cách cấu hình URL trong SecurityFilterChain:


    .formLogin(form -> form
        .loginPage("/login") // URL hiển thị form đăng nhập
        .loginProcessingUrl("/doLogin") // URL Spring Security xử lý yêu cầu đăng nhập (mặc định là /login POST)
        .defaultSuccessUrl("/", true) // URL chuyển hướng sau khi thành công (true = luôn chuyển hướng)
        .failureUrl("/login?error") // URL khi đăng nhập thất bại
        .permitAll() // Cho phép truy cập trang login và các URL liên quan
    )
    .logout(logout -> logout
        .logoutUrl("/logout") // URL để kích hoạt đăng xuất (mặc định POST)
        .logoutSuccessUrl("/login?logout") // URL sau khi đăng xuất thành công
        .invalidateHttpSession(true) // Hủy phiên HTTP sau khi đăng xuất
        .deleteCookies("JSESSIONID") // Xóa cookie phiên
        .permitAll() // Cho phép truy cập URL logout
    );

Bạn cần tạo Controller để xử lý các URL /login và /logout (dù /logout thường chỉ cần mapping để Spring Security bắt lấy). Trang HTML/Template cho /login cần có form với action là URL bạn đã cấu hình trong loginProcessingUrl() (hoặc mặc định là /login) và các input cho username (mặc định tên là username) và password (mặc định tên là password).


<!-- login.html (ví dụ dùng Thymeleaf) -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login</title>
</head>
<body>
    <div th:if="${param.error}">
        Invalid username and password.
    </div>
    <div th:if="${param.logout}">
        You have been logged out.
    </div>
    <form th:action="@{/doLogin}" method="post"> <!-- Sử dụng loginProcessingUrl -->
        <div><label> User Name : <input type="text" name="username"/></label></div>
        <div><label> Password: <input type="password" name="password"/></label></div>
        <div><input type="submit" value="Sign In"/></div>
    </form>
</body>
</html>


import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class LoginController {

    @GetMapping("/login")
    public String login() {
        return "login"; // Trả về tên template login.html
    }

    // Không cần mapping cho /doLogin hay /logout, Spring Security đã xử lý
}

Với cấu hình này, khi người dùng truy cập một trang yêu cầu xác thực mà chưa đăng nhập, họ sẽ được chuyển hướng đến /login. Sau khi submit form tại /login, Spring Security sẽ bắt lấy yêu cầu POST đến /doLogin, thực hiện xác thực. Nếu thành công, chuyển hướng đến /; nếu thất bại, chuyển hướng đến /login?error. Truy cập /logout (thường qua POST) sẽ kích hoạt quá trình đăng xuất.

Tổng kết các thành phần chính

Để củng cố kiến thức, đây là bảng tóm tắt các thành phần chính liên quan đến cấu hình xác thực:

Thành phần Vai trò Cách cấu hình/Triển khai
SecurityFilterChain Định nghĩa chuỗi bộ lọc bảo mật, cấu hình các quy tắc HTTP (URL patterns, form login, logout, CSRF, etc.) Bean `@Bean` trong `@Configuration` class
HttpSecurity Fluent API để cấu hình SecurityFilterChain Đối tượng được inject vào phương thức `@Bean SecurityFilterChain`
UserDetails Biểu diễn thông tin người dùng đã xác thực (username, password, authorities, enabled, locked, etc.) Interface, thường sử dụng builder `User.builder()` hoặc lớp triển khai của bạn
UserDetailsService Tải thông tin UserDetails dựa trên username Interface, cung cấp Bean `@Bean` lớp triển khai (`InMemoryUserDetailsManager`, `CustomUserDetailsService`, v.v.)
PasswordEncoder Mã hóa (hash) và so sánh mật khẩu Interface, cung cấp Bean `@Bean` lớp triển khai (`BCryptPasswordEncoder`, `DelegatingPasswordEncoder`, v.v.)
AuthenticationProvider Thực hiện logic xác thực thực tế, sử dụng UserDetailsService và PasswordEncoder Nội bộ của Spring Security, được tự động cấu hình khi có Bean UserDetailsService/PasswordEncoder
AuthenticationManager Quản lý các AuthenticationProvider, là điểm vào chính của quy trình xác thực Nội bộ của Spring Security, được tự động cấu hình
SecurityContextHolder Lưu trữ Authentication của người dùng hiện tại Static class, truy cập thông tin người dùng hiện tại qua `SecurityContextHolder.getContext().getAuthentication()`

Tiếp theo là gì?

Sau khi nắm vững xác thực cơ bản, bạn có thể khám phá:

  • Authorization (Phân quyền): Sử dụng các biểu thức (expressions) trong requestMatchers hoặc annotations như @PreAuthorize, @PostAuthorize để kiểm soát quyền truy cập chi tiết hơn (đã đề cập sơ qua trong bài này và bài 101).
  • Các phương thức xác thực khác: Basic Authentication, Digest Authentication, OAuth2, OpenID Connect, JWT (JSON Web Tokens), xác thực dựa trên chứng chỉ client.
  • Tích hợp với các hệ thống quản lý danh tính: LDAP, Active Directory, Okta, Keycloak, v.v.
  • Cấu hình nâng cao: Custom Authentication Filter, Exception Handling, Remember Me, Session Management.
  • Bảo mật cho API REST: Sử dụng xác thực không trạng thái (stateless) với JWT.

Kết luận

Việc cấu hình xác thực là một bước quan trọng không thể thiếu khi xây dựng các ứng dụng thực tế với Spring. Spring Security cung cấp một framework mạnh mẽ và linh hoạt để xử lý tác vụ này. Bằng cách hiểu rõ các thành phần chính như SecurityFilterChain, UserDetailsService, và PasswordEncoder, bạn có thể tùy chỉnh quy trình xác thực để phù hợp với yêu cầu ứng dụng của mình, cho dù là sử dụng dữ liệu người dùng từ bộ nhớ, cơ sở dữ liệu, hay một nguồn khác.

Hãy thực hành bằng cách tạo một ứng dụng Spring Boot nhỏ, thêm Spring Security, và cấu hình xác thực in-memory hoặc dựa trên database đơn giản. Thử bảo vệ các URL khác nhau và kiểm tra cách nó hoạt động.

Đây là một bước tiến lớn trên Spring Boot Roadmap của bạn. Trong các bài viết tiếp theo, chúng ta sẽ tiếp tục khám phá các khía cạnh khác của Spring ecosystem. Hẹn gặp lại!

Recent News Articles

Fresh job related news content posted each day.

Mục lục

→ Chỉ mục