后端进阶之路——万字总结Spring Security与数据库集成实践（五）

柔光的暖阳◎ 2023-10-14 13:54 10阅读 0赞

# 前言 #

![在这里插入图片描述][0422b4369a3549b3a39da19588ab88f4.png]  
「作者主页」：[雪碧有白泡泡][Link 1]  
「个人网站」：[雪碧的个人网站][Link 2]  
「推荐专栏」：

> ★[java一站式服务][java] ★  
> ★[前端炫酷代码分享][Link 3]  
> ★ ★ [uniapp-从构建到提升][uniapp-]★  
> ★ [从0到英雄，vue成神之路][0_vue]★  
> ★ [解决算法，一个专栏就够了][Link 4]★  
> ★ [架构咱们从0说][0]★  
> ★ [数据流通的精妙之道][Link 5]★
> 
> ★[后端进阶之路][Link 6]★

![请添加图片描述][c7f3e6b8a7624a9eabbea77dbcbca119.jpeg]

### 文章目录 ###

*  前言
 *  1. 引言
 *   *  使用数据库集成Spring Security的目的和好处
 *  2. 数据库设计与配置
 *   *  2.1 用户表的结构和字段
     *  2.2 角色表的结构和字段
     *  2.3 配置Spring Security与数据库的连接
 *  3. 用户认证
 *   *  3.1 实现基于数据库的用户认证功能
     *  3.2 使用Spring Security的Encoder进行密码加密和验证
     *  4.3 自定义用户认证的逻辑和处理方式
 *  4. 用户授权
 *   *  4.1 基于数据库的用户授权功能
     *  4.2 在数据库中定义角色和权限
     *  4.3 配置权限验证规则和授权方式
     *  4.4 自定义用户授权的逻辑和处理方式
 *  小结

![在这里插入图片描述][1238f4ff4059480db529d17ae74406e4.png]

# 1. 引言 #

## 使用数据库集成Spring Security的目的和好处 ##

1.  数据库作为存储用户信息的可靠源：将用户信息存储在数据库中可以保证其持久性和安全性，并且可方便地进行管理和维护。
2.  灵活的用户认证和授权配置：通过数据库集成，可以实现对不同用户的不同认证和授权方式，例如基于角色的访问控制或基于权限的细粒度控制。
3.  可拓展性和可定制化：通过数据库集成，可以轻松地添加新的用户、角色和权限，并且能够根据具体需求进行自定义身份验证和授权逻辑的开发。
4.  统一管理用户信息：通过数据库集成，可以实现统一管理用户信息。当用户信息发生变化时，例如更改密码、添加或删除角色等，只需在数据库中进行修改即可。

> **在本文中，我们将深入探讨如何将Spring Security与数据库集成，实现基于数据库的用户身份验证和授权。我们将介绍Spring Security的基本概念和功能，讨论数据库设计和配置的具体细节，并提供完整的示例代码来演示这种集成方式的实际应用。通过阅读本文，读者将能够理解和应用这种集成方式，构建安全可靠的认证和授权系统。**

![在这里插入图片描述][8c366a776797410e86100b490963987a.png]

# 2. 数据库设计与配置 #

在使用数据库进行身份验证和授权时，我们需要设计和配置适合存储用户信息和角色信息的数据库结构。这些信息通常存储在两张表中：用户表和角色表。

## 2.1 用户表的结构和字段 ##

用户表通常包含以下字段：

*  `id`: 用户的唯一标识符
 *  `username`: 用户名
 *  `password`: 经过加密的密码
 *  `enabled`: 标识用户是否启用（例如，激活状态）
 *  其他可选字段，如`email`、`phone`等

以下是一个示例用户表的SQL定义：

CREATE TABLE users (
      id INT PRIMARY KEY AUTO_INCREMENT,
      username VARCHAR(64) NOT NULL,
      password VARCHAR(256) NOT NULL,
      enabled BOOLEAN NOT NULL,
      email VARCHAR(128),
      phone VARCHAR(16)
    );

## 2.2 角色表的结构和字段 ##

角色表用于定义不同用户角色，并且与用户表之间存在关联。角色表通常包含以下字段：

*  `id`: 角色的唯一标识符
 *  `name`: 角色名称

以下是一个示例角色表的SQL定义：

CREATE TABLE roles (
      id INT PRIMARY KEY AUTO_INCREMENT,
      name VARCHAR(64) NOT NULL
    );

## 2.3 配置Spring Security与数据库的连接 ##

在Spring Security中配置与数据库的连接，需要提供数据库的连接信息、用户名、密码等配置。我们可以使用Spring的配置文件（如`application.properties`）或Java配置类来配置数据库连接。

以下是一个示例的`application.properties`文件配置数据库连接：

spring.datasource.url=jdbc:mysql://localhost:3306/security_db
    spring.datasource.username=db_username
    spring.datasource.password=db_password
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver

在Spring Security配置中，我们需要配置一个`UserDetailsService`，它负责从数据库中加载用户信息并提供给Spring Security进行身份验证和授权。

以下是一个示例的Java配置类示例，其中配置了`UserDetailsService`：

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private DataSource dataSource;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.jdbcAuthentication()
                    .dataSource(dataSource)
                    .usersByUsernameQuery("SELECT username, password, enabled FROM users WHERE username = ?")
                    .authoritiesByUsernameQuery("SELECT u.username, r.name FROM users u, roles r, user_roles ur WHERE u.id = ur.user_id AND r.id = ur.role_id AND u.username = ?");
        }
    
        // Other security configurations...
    }

在上述示例中，我们通过`dataSource`注入配置的数据库连接。`usersByUsernameQuery`和`authoritiesByUsernameQuery`用于自定义查询用户信息和角色/权限的SQL语句。

> 通过以上的数据库设计和配置，我们可以建立一个与Spring  
> Security集成的数据库，以存储用户和角色信息，并通过配置文件或Java配置类与Spring  
> Security建立连接。这将为我们的身份验证和授权提供基础。

# 3. 用户认证 #

> 用户认证是确保用户身份有效性的过程。在基于数据库的用户认证中，我们将使用Spring Security来实现用户认证功能。

## 3.1 实现基于数据库的用户认证功能 ##

通过配置`UserDetailsService`，我们可以从数据库中加载用户信息，并将其与用户提交的凭据进行比较以验证其身份。

以下是一个示例的`UserDetailsService`实现类，用于从数据库中加载用户信息：

@Service
    public class UserDetailsServiceImpl implements UserDetailsService {
        
    
        @Autowired
        private UserRepository userRepository;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            User user = userRepository.findByUsername(username);
            if (user == null) {
        
                throw new UsernameNotFoundException("User not found");
            }
            return new org.springframework.security.core.userdetails.User(
                    user.getUsername(),
                    user.getPassword(),
                    user.getAuthorities()
            );
        }
    }

在上述示例中，我们注入了`UserRepository`，该接口用于查询数据库中的用户信息。

## 3.2 使用Spring Security的Encoder进行密码加密和验证 ##

为了保护用户密码的安全性，我们需要对密码进行加密并进行比较。Spring Security提供了多种加密方式，例如BCrypt、SHA-256等。

以下是一个示例的密码加密和验证示例：

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private PasswordEncoder passwordEncoder;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.userDetailsService(userDetailsService())
                .passwordEncoder(passwordEncoder);
        }
    
        @Bean
        public PasswordEncoder passwordEncoder() {
        
            return new BCryptPasswordEncoder();
        }
    
        // Other security configurations...
    }

在上述示例中，我们配置了一个`PasswordEncoder` bean，并将其注入到`AuthenticationManagerBuilder`中。这样，当用户登录时，Spring Security会自动将用户输入的密码与数据库中存储的加密密码进行比较。

## 4.3 自定义用户认证的逻辑和处理方式 ##

通过实现`UserDetailsService`接口和使用`PasswordEncoder`，我们可以实现基于数据库的用户认证。但有时我们可能需要自定义用户认证的逻辑和处理方式。

以下是一个示例的自定义用户认证的配置示例：

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private UserDetailsService userDetailsService;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.authenticationProvider(customAuthenticationProvider());
        }
    
        @Bean
        public AuthenticationProvider customAuthenticationProvider() {
        
            CustomAuthenticationProvider authenticationProvider = new CustomAuthenticationProvider();
            authenticationProvider.setUserDetailsService(userDetailsService);
            authenticationProvider.setPasswordEncoder(passwordEncoder());
            return authenticationProvider;
        }
    
        // Other security configurations...
    }

在上述示例中，我们实现自定义的`CustomAuthenticationProvider`，并将其注册为`AuthenticationProvider`。`CustomAuthenticationProvider`可以实现自定义的用户认证逻辑，例如通过额外的验证步骤、读取其他系统的用户信息等。

以下是一个示例的`CustomAuthenticationProvider`类：

public class CustomAuthenticationProvider implements AuthenticationProvider {
        
    
        private UserDetailsService userDetailsService;
        private PasswordEncoder passwordEncoder;
    
        @Override
        public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        
            String username = authentication.getName();
            String password = authentication.getCredentials().toString();
    
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
    
            if (passwordEncoder.matches(password, userDetails.getPassword())) {
        
                return new UsernamePasswordAuthenticationToken(username, password, userDetails.getAuthorities());
            } else {
        
                throw new BadCredentialsException("Invalid credentials");
            }
        }
    
        @Override
        public boolean supports(Class<?> authentication) {
        
            return UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication);
        }
    
        // Setter methods for UserDetailsService and PasswordEncoder
    }

在上述示例中，我们通过`UserDetailsService`加载用户信息，并使用`PasswordEncoder`验证密码。如果用户认证通过，我们创建一个`UsernamePasswordAuthenticationToken`对象来表示成功的认证。

通过自定义用户认证逻辑和处理方式，我们可以灵活地应对各种特定的认证需求，如双因素身份验证、第三方认证等。

> 通过以上的实现和配置，我们可以实现基于数据库的用户认证。Spring Security将会验证用户提交的凭证，并根据数据库中的用户信息进行身份验证。为了保障密码的安全性，我们可以使用SpringSecurity提供的加密方式对密码进行加密和验证。同时，如果需要自定义用户认证逻辑和处理方式，我们可以实现自己的`CustomAuthenticationProvider`来满足特定的需求。  
> ![在这里插入图片描述][e71546cff50f449292f14bf810536f7a.png]

# 4. 用户授权 #

> 用户授权是为了确定用户能够访问系统中特定资源的权限。在基于数据库的用户授权功能中，我们将使用数据库中定义的角色和权限进行授权操作。

## 4.1 基于数据库的用户授权功能 ##

通过配置Spring Security，我们可以使用数据库中定义的角色和权限对用户进行授权。

以下是一个示例的权限验证规则和授权方式的配置：

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private UserDetailsService userDetailsService;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasAnyRole("ADMIN", "USER")
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .logout();
        }
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.userDetailsService(userDetailsService);
        }
    
        // Other security configurations...
    }

在上述示例中，我们通过`antMatchers`定义了不同URL路径的权限验证规则。例如，"/admin/**“路径需要具有"ADMIN"角色才能访问，而”/user/**"路径需要具有"ADMIN"或"USER"角色才能访问。

## 4.2 在数据库中定义角色和权限 ##

为了实现基于数据库的用户授权功能，我们需要在数据库中定义角色和权限。

以下是一个示例的角色表和权限表的定义：

CREATE TABLE roles (
      id INT PRIMARY KEY AUTO_INCREMENT,
      name VARCHAR(64) NOT NULL
    );
    
    CREATE TABLE permissions (
      id INT PRIMARY KEY AUTO_INCREMENT,
      name VARCHAR(64) NOT NULL
    );

然后，我们需要定义用户与角色之间的关联，以及角色与权限之间的关联。

以下是一个示例的用户角色关联表和角色权限关联表的定义：

CREATE TABLE user_roles (
       user_id INT NOT NULL,
       role_id INT NOT NULL,
       PRIMARY KEY (user_id, role_id),
       FOREIGN KEY (user_id) REFERENCES users(id),
       FOREIGN KEY (role_id) REFERENCES roles(id)
    );
    
    CREATE TABLE role_permissions (
       role_id INT NOT NULL,
       permission_id INT NOT NULL,
       PRIMARY KEY (role_id, permission_id),
       FOREIGN KEY (role_id) REFERENCES roles(id),
       FOREIGN KEY (permission_id) REFERENCES permissions(id)
    );

通过以上的数据库定义，我们可以在数据库中建立用户、角色和权限的关联关系，并在用户授权时使用。

## 4.3 配置权限验证规则和授权方式 ##

在上述的Spring Security配置中，我们使用`antMatchers`定义了访问路径的权限验证规则，并指定了需要具有哪些角色才能访问对应的路径。

除了使用角色进行访问控制外，我们也可以使用权限进行访问控制。权限是角色的组成部分，每个角色可以具有多个权限。

以下是一个示例的权限验证规则和授权方式的配置，基于数据库中的角色和权限：

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private UserDetailsService userDetailsService;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                .antMatchers("/admin/**").hasAuthority("ADMIN_ACCESS")
                .antMatchers("/user/**").hasAnyAuthority("ADMIN_ACCESS", "USER_ACCESS")
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .logout();
        }
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.userDetailsService(userDetailsService);
        }
    
        // Other security configurations...
    }

在上述示例中，我们使用`hasAuthority`和`hasAnyAuthority`来配置权限验证规则。例如，"/admin/**“路径需要具有"ADMIN\_ACCESS"权限才能访问，而”/user/**"路径需要具有"ADMIN\_ACCESS"或"USER\_ACCESS"权限才能访问。

## 4.4 自定义用户授权的逻辑和处理方式 ##

通过自定义`UserDetailsService`和`AuthenticationProvider`，我们可以实现自定义的用户授权逻辑和处理方式。

例如，在`UserDetailsService`中，我们可以根据具体的业务逻辑从数据库中加载用户信息和授权信息。在`AuthenticationProvider`中，我们可以实现自定义的授权逻辑，例如根据用户的其他属性进行额外的授权判断。

通过自定义用户授权的逻辑和处理方式，我们可以灵活地定义和调整系统中的权限控制方式，以满足不同的业务需求。

# 小结 #

这篇文章的主要目标是展示如何将Spring Security与数据库集成，实现基于数据库的用户身份认证和授权。通过引入数据库，并配合Spring Security的功能和配置，可以构建一个安全可靠的用户认证和授权系统  
![在这里插入图片描述][fa6dfcb891b249f99f443b77c730f5db.png]

[0422b4369a3549b3a39da19588ab88f4.png]: https://img-blog.csdnimg.cn/0422b4369a3549b3a39da19588ab88f4.png
[Link 1]: https://blog.csdn.net/Why_does_it_work?spm=1011.2415.3001.5343
[Link 2]: https://sprite.inscode.cc/
[java]: https://blog.csdn.net/why_does_it_work/category_12379581.html
[Link 3]: https://blog.csdn.net/why_does_it_work/category_12378617.html
[uniapp-]: https://blog.csdn.net/why_does_it_work/category_12363697.html
[0_vue]: https://blog.csdn.net/why_does_it_work/category_12376654.html
[Link 4]: https://blog.csdn.net/why_does_it_work/category_12381051.html
[0]: https://blog.csdn.net/why_does_it_work/category_12381055.html
[Link 5]: https://blog.csdn.net/why_does_it_work/category_12381058.html
[Link 6]: https://blog.csdn.net/why_does_it_work/category_12397959.html?spm=1001.2014.3001.5482
[c7f3e6b8a7624a9eabbea77dbcbca119.jpeg]: https://img-blog.csdnimg.cn/c7f3e6b8a7624a9eabbea77dbcbca119.jpeg
[1238f4ff4059480db529d17ae74406e4.png]: https://img-blog.csdnimg.cn/1238f4ff4059480db529d17ae74406e4.png
[8c366a776797410e86100b490963987a.png]: https://img-blog.csdnimg.cn/8c366a776797410e86100b490963987a.png
[e71546cff50f449292f14bf810536f7a.png]: https://img-blog.csdnimg.cn/e71546cff50f449292f14bf810536f7a.png
[fa6dfcb891b249f99f443b77c730f5db.png]: https://img-blog.csdnimg.cn/fa6dfcb891b249f99f443b77c730f5db.png