Spring Security学习与探究系列（二）：从数据库中加载用户以及用户权限验证

前言

在上一篇文章中，笔者介绍了Spring Security的简单使用，但同时也遗留了一些问题。在本篇文章中，笔者将进一步探究Spring Security的使用方法，主要聚焦于以下两个问题：从数据库中加载账户数据和为账户定义不同的权限。我们知道，一个常见的网站除了身份验证之外，还应该有权限验证，因为不同身份可以访问的资源应该是不一样的。比如博客系统，普通用户可以正常管理自己发布的文章，而管理员则可以对所有普通用户的文章进行管理。

实现

下面逐步来介绍怎么实现本文的目标。

1.配置POM文件

我们新建一个SpringBoot项目，使用IDEA所提供的Spring Initializr，同时勾选Spring Security、JDBC API、MyBatis和thymeleaf等组件，创建项目完毕后，其pom.xml文件的配置如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringSecurityDemo2</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
    	<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>
		<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.数据库相关配置

由于需要从数据库中加载账户数据，因此我们需要先创建一个用户数据表。为了简单起见，用户数据表仅有以下几个字段：ID、用户名、密码、性别和权限。这里的权限以字符串形式存在，分别有两个权限：user和admin，代表了普通权限和管理员权限，不同的权限将能访问到不同的资源。

笔者所使用的数据库为MySQL8.0，创建一个springsecuritydemo2的数据库，然后创建user数据表，其SQL语句如下所示：

CREATE TABLE `springsecuritydemo2`.`user` (
  `id` INT NOT NULL AUTO_INCREMENT,
  `username` VARCHAR(45) NOT NULL,
  `password` VARCHAR(90) NOT NULL,
  `sex` VARCHAR(45) NOT NULL,
  `authority` VARCHAR(45) NOT NULL,
  PRIMARY KEY (`id`));

创建数据表后，我们新增两条数据如下：

INSERT INTO `springsecuritydemo2`.`user` (`id`, `username`, `password`, `sex`, `authority`) VALUES ('1', 'user', '$2a$10$O0LmLvs6sPVR4oy7StpgzuIaZY2jnToS/u38EsWxfKofIBY6W5POm', '男', 'user');
INSERT INTO `springsecuritydemo2`.`user` (`id`, `username`, `password`, `sex`, `authority`) VALUES ('2', 'admin', '$2a$10$O0LmLvs6sPVR4oy7StpgzuIaZY2jnToS/u38EsWxfKofIBY6W5POm', '男', 'user,admin');

分别为user和admin，二者的明文密码均是123456，user的权限只有user，而admin的权限包括了user和admin。可以看出，存储在数据库中的密码是密文存储，这里使用的是BCryptPasswordEncoder对123456进行加密得到的密码。

3.与MyBatis有关的配置

接下来，由于我们使用MyBatis作为读取数据库的框架，因此需要先对MyBatis进行配置，在application.properties文件下进行如下配置：

spring.datasource.url=jdbc:mysql://localhost:3306/springsecuritydemo2?setUnicode=true&characterEncoding=utf8&serverTimezone=UTC
spring.datasource.username=[你数据库的用户名]
spring.datasource.password=[你数据库的密码]
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

还需建立一个Mapper文件，而在查询数据库的过程中，需要有一个Java Bean与数据表的字段相对应。我们先建立一个UserBean类，用于表示数据表user的一行数据：

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@Component
public class UserBean implements UserDetails {

    private int id;
    private String username;
    private String password;
    private String sex;
    private String authority;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        String[] authorities = authority.split(",");	//由于数据库中authority字段里面是用","来分隔每个权限
        List<SimpleGrantedAuthority> simpleGrantedAuthorities = new ArrayList<>();
        for (String role : authorities){
            simpleGrantedAuthorities.add(new SimpleGrantedAuthority(role));
        }
        return simpleGrantedAuthorities;
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

上述的UserBean与常见的Bean的不同之处在于，实现了UserDetails接口，该接口是Spring Security提供的与用户验证与鉴权有关的接口，所需要重写的几个方法具体解释如下：

1. Collection<? extends GrantedAuthority> getAuthorities()：返回当前用户所支持的权限
2. String getPassword()：返回当前用户的密码
3. String getUsername()：返回当前用户的用户名
4. boolean isAccountNonExpired()：返回当前用户是否过期
5. boolean isAccountNonLocked()：返回当前用户是否被锁定
6. boolean isCredentialsNonExpired()：返回当前用户权限是否过期
7. boolean isEnabled()：返回当前用户是否可用

在本文中，仅对用户权限进行了处理，别的账户状态如是否过期等，可以结合具体的项目及数据库来自行实现。
下面，建立Mapper文件，该文件实现SQL语句到Java代码的映射，新建UserMapper文件如下：

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

@Mapper
@Component
public interface UserMapper {

    @Select("select * from user where username = #{username}")
    UserBean getUserByUsername(@Param("username") String username);
}

代码很简单，使用@Select标注来写入SQL语句即可，这里根据username在user表中查询对应的行。

4.准备几个前端页面

本小节来准备几个前端页面，分别是user.html和admin.html，登录页面使用Spring Security默认的login页面，为了方便起见，所使用的前端页面都很简单，仅作为一个示例使用。在resources文件夹下新建一个templates文件夹，然后新增下面两个html文件。

1. admin.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org" lang="en">
<head>
    <meta charset="UTF-8">
    <title>Admin</title>
</head>
<body>
<h3>登录成功，该页面需要Admin权限才能访问</h3>
<div style="display: flex">
    <p>用户名：</p><p th:text="${username}"></p>
</div>
</body>
</html>

2. user.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org" lang="en">
<head>
    <meta charset="UTF-8">
    <title>User</title>
</head>
<body>
<h3>登录成功，该页面需要User权限才能访问</h3>
<div style="display: flex">
    <p>用户名：</p><p th:text="${username}"></p>
</div>
</body>
</html>

5.配置Spring Security

本小节介绍如何配置Spring Security以实现上述功能。根据上一篇文章的内容，我们需要创建一个SecurityConfig继承WebSecurityConfigurerAdapter。由于我们这里的需求是加载数据库的账户数据来进行验证，我们还需要一个验证器。在Spring Security中，提供了一个UserDetailsService的接口，允许我们以自定义的方式加载UserBean，因此，我们可以在这里实现从数据库中读取UserBean。
创建DBUserDetailsService .java文件：

@Service
public class DBUserDetailsService implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;
    
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        return userMapper.getUserByUsername(s);
    }
}

上面代码中，使用了UserMapper来读取数据库的用户数据。接下来，我们创建SecurityConfig文件，实现对Spring Security的配置：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.DefaultRedirectStrategy;

import java.util.Set;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    DBUserDetailsService dbUserDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //添加自定义的验证器
        auth.userDetailsService(dbUserDetailsService).passwordEncoder(new BCryptPasswordEncoder());
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();  //关闭CSRF验证
        http.authorizeRequests()
                .antMatchers("/user").hasAuthority("user")  //访问/user接口需要[user]权限
                .antMatchers("/admin").hasAuthority("admin")//访问/admin接口需要[admin]权限
                .and()
                .formLogin()
                .successHandler((httpServletRequest, httpServletResponse, authentication) -> {
                    Set<String> authorities = AuthorityUtils.authorityListToSet(authentication.getAuthorities());
                    if (authorities.contains("admin")){
                        //如果有admin权限，则跳转至/admin页面
                        new DefaultRedirectStrategy().sendRedirect(httpServletRequest, httpServletResponse, "/admin");
                    }else {
                        //否则跳转至/user页面
                        new DefaultRedirectStrategy().sendRedirect(httpServletRequest, httpServletResponse, "/user");
                    }
                });
    }
}

在上述代码中，为/user和’/admin’页面分别添加了不同的权限，并且根据登录的用户所有的权限来自动跳转到不同的页面。代码写到这里就差不多了，事不宜迟，我们马上来运行代码看看结果。

运行结果

1、在浏览器输入locahost:8080/login，得到默认的登录页面如下：
2、输入admin和123465观察其跳转情况：

3、输入user和123456观察其跳转情况：

运行结果很成功，完整地实现了本文一开始所聚焦的两个问题。最后再次感谢你们的阅读~