Springboot+Spring Security实现前后端分离登录认证及权限控制的示例代码

前言

    关于spring security的概念部分本文不进行赘述，本文主要针对于对spring security以及springboot有一定了解的小伙伴，帮助大家使用springboot + spring security 实现一个前后端分离登录认证的过程。
    文章会一步一步循序渐进的带大家敲一遍代码。最终的代码请看最后。
    代码中我用到了插件lombok来生成实体的getter/setter，如果不想装插件请自己补全getter/setter

本文主要的功能

1、前后端分离用户登录认证
2、基于rbac（角色）的权限控制

 一、准备工作

1、统一错误码枚举

/**
 * @author: hutengfei
 * @description: 返回码定义
 * 规定:
 * #1表示成功
 * #1001～1999 区间表示参数错误
 * #2001～2999 区间表示用户错误
 * #3001～3999 区间表示接口异常
 * @date create in 2019/7/22 19:28
 */
public enum resultcode {
    /* 成功 */
    success(200, "成功"),

    /* 默认失败 */
    common_fail(999, "失败"),

    /* 参数错误：1000～1999 */
    param_not_valid(1001, "参数无效"),
    param_is_blank(1002, "参数为空"),
    param_type_error(1003, "参数类型错误"),
    param_not_complete(1004, "参数缺失"),

    /* 用户错误 */
    user_not_login(2001, "用户未登录"),
    user_account_expired(2002, "账号已过期"),
    user_credentials_error(2003, "密码错误"),
    user_credentials_expired(2004, "密码过期"),
    user_account_disable(2005, "账号不可用"),
    user_account_locked(2006, "账号被锁定"),
    user_account_not_exist(2007, "账号不存在"),
    user_account_already_exist(2008, "账号已存在"),
    user_account_use_by_others(2009, "账号下线"),

    /* 业务错误 */
    no_permission(3001, "没有权限");
    private integer code;
    private string message;

    resultcode(integer code, string message) {
        this.code = code;
        this.message = message;
    }

    public integer getcode() {
        return code;
    }

    public void setcode(integer code) {
        this.code = code;
    }

    public string getmessage() {
        return message;
    }

    public void setmessage(string message) {
        this.message = message;
    }

    /**
     * 根据code获取message
     *
     * @param code
     * @return
     */
    public static string getmessagebycode(integer code) {
        for (resultcode ele : values()) {
            if (ele.getcode().equals(code)) {
                return ele.getmessage();
            }
        }
        return null;
    }
}

2、统一json返回体

/**
 * @author: hutengfei
 * @description: 统一返回实体
 * @date create in 2019/7/22 19:20
 */
public class jsonresult<t> implements serializable {
    private boolean success;
    private integer errorcode;
    private string errormsg;
    private t data;

    public jsonresult() {
    }

    public jsonresult(boolean success) {
        this.success = success;
        this.errorcode = success ? resultcode.success.getcode() : resultcode.common_fail.getcode();
        this.errormsg = success ? resultcode.success.getmessage() : resultcode.common_fail.getmessage();
    }

    public jsonresult(boolean success, resultcode resultenum) {
        this.success = success;
        this.errorcode = success ? resultcode.success.getcode() : (resultenum == null ? resultcode.common_fail.getcode() : resultenum.getcode());
        this.errormsg = success ? resultcode.success.getmessage() : (resultenum == null ? resultcode.common_fail.getmessage() : resultenum.getmessage());
    }

    public jsonresult(boolean success, t data) {
        this.success = success;
        this.errorcode = success ? resultcode.success.getcode() : resultcode.common_fail.getcode();
        this.errormsg = success ? resultcode.success.getmessage() : resultcode.common_fail.getmessage();
        this.data = data;
    }

    public jsonresult(boolean success, resultcode resultenum, t data) {
        this.success = success;
        this.errorcode = success ? resultcode.success.getcode() : (resultenum == null ? resultcode.common_fail.getcode() : resultenum.getcode());
        this.errormsg = success ? resultcode.success.getmessage() : (resultenum == null ? resultcode.common_fail.getmessage() : resultenum.getmessage());
        this.data = data;
    }

    public boolean getsuccess() {
        return success;
    }

    public void setsuccess(boolean success) {
        this.success = success;
    }

    public integer geterrorcode() {
        return errorcode;
    }

    public void seterrorcode(integer errorcode) {
        this.errorcode = errorcode;
    }

    public string geterrormsg() {
        return errormsg;
    }

    public void seterrormsg(string errormsg) {
        this.errormsg = errormsg;
    }

    public t getdata() {
        return data;
    }

    public void setdata(t data) {
        this.data = data;
    }
}

3、返回体构造工具

/**
 * @author: hutengfei
 * @description:
 * @date create in 2019/7/22 19:52
 */
public class resulttool {
    public static jsonresult success() {
        return new jsonresult(true);
    }

    public static <t> jsonresult<t> success(t data) {
        return new jsonresult(true, data);
    }

    public static jsonresult fail() {
        return new jsonresult(false);
    }

    public static jsonresult fail(resultcode resultenum) {
        return new jsonresult(false, resultenum);
    }
}

4、pom

<?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.1.7.release</version>
        <relativepath/> <!-- lookup parent from repository -->
    </parent>
    <groupid>com.spring</groupid>
    <artifactid>security</artifactid>
    <version>0.0.1-snapshot</version>
    <name>security</name>
    <description>测试spring-security工程</description>

    <properties>
        <java.version>1.8</java.version>
        <spring.security.version>5.1.6.release</spring.security.version>
        <fastjson.version>1.2.46</fastjson.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-test</artifactid>
            <scope>test</scope>
        </dependency>
        <!-- spring-security -->
        <dependency>
            <groupid>org.springframework.security</groupid>
            <artifactid>spring-security-web</artifactid>
            <version>${spring.security.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework.security</groupid>
            <artifactid>spring-security-config</artifactid>
            <version>${spring.security.version}</version>
        </dependency>
        <!-- hikari连接池-->
        <dependency>
            <groupid>com.zaxxer</groupid>
            <artifactid>hikaricp</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-jdbc</artifactid>
            <exclusions>
                <!-- 排除 tomcat-jdbc 以使用 hikaricp -->
                <exclusion>
                    <groupid>org.apache.tomcat</groupid>
                    <artifactid>tomcat-jdbc</artifactid>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
            <version>${mysql.version}</version>
        </dependency>
        <!-- mybatis-plus-->
        <dependency>
            <groupid>com.baomidou</groupid>
            <artifactid>mybatisplus-spring-boot-starter</artifactid>
            <version>1.0.5</version>
        </dependency>
        <dependency>
            <groupid>com.baomidou</groupid>
            <artifactid>mybatis-plus</artifactid>
            <version>2.1.9</version>
        </dependency>
        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
        </dependency>
        <!--json-->
        <dependency>
            <groupid>com.alibaba</groupid>
            <artifactid>fastjson</artifactid>
            <version>${fastjson.version}</version>
        </dependency>
        <dependency>
            <groupid>org.apache.commons</groupid>
            <artifactid>commons-lang3</artifactid>
            <version>3.8.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>

</project>

5、配置文件

spring:
  application:
    name: isoftstone-security
  datasource:
    type: com.zaxxer.hikari.hikaridatasource
    driver-class-name: com.mysql.cj.jdbc.driver
    url: jdbc:mysql://localhost:3306/spring_security?useunicode=true&characterencoding=utf-8&usessl=false&servertimezone=ctt
    username: root
    password: root
    hikari:
      minimum-idle: 5
      idle-timeout: 600000
      maximum-pool-size: 10
      auto-commit: true
      pool-name: myhikaricp
      max-lifetime: 1800000
      connection-timeout: 30000
      connection-test-query: select 1
server:
  port: 8666

mybatis-plus:
  # 如果是放在src/main/java目录下 classpath:/com/yourpackage/*/mapper/*mapper.xml
  # 如果是放在resource目录 classpath:/mapper/*mapper.xml
  mapper-locations: classpath:mapper/*.xml, classpath:mybatis/mapping/**/*.xml
  #实体扫描，多个package用逗号或者分号分隔
  typealiasespackage: com.spring.**
  global-config:
    #主键类型  0:"数据库id自增", 1:"用户输入id",2:"全局唯一id (数字类型唯一id)", 3:"全局唯一id uuid";
    id-type: 0
    #字段策略 0:"忽略判断",1:"非 null 判断"),2:"非空判断"
    field-strategy: 1
    #驼峰下划线转换
    db-column-underline: true
    #刷新mapper 调试神器
    refresh-mapper: true
    #数据库大写下划线转换
    #capital-mode: true
    #序列接口实现类配置,不在推荐使用此方式进行配置,请使用自定义bean注入
    #key-generator: com.baomidou.mybatisplus.incrementer.h2keygenerator
    #逻辑删除配置（下面3个配置）
    logic-delete-value: 0
    logic-not-delete-value: 1
    #自定义sql注入器,不在推荐使用此方式进行配置,请使用自定义bean注入
    #sql-injector: com.baomidou.mybatisplus.mapper.logicsqlinjector
    #自定义填充策略接口实现,不在推荐使用此方式进行配置,请使用自定义bean注入
    # meta-object-handler: com.baomidou.springboot.mymetaobjecthandler
    #自定义sql注入器
    #sql-injector: com.baomidou.springboot.xxx
    # sql 解析缓存，开启后多租户 @sqlparser 注解生效
    sql-parser-cache: true
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: false

二、数据库表设计

建表语句

create table sys_user
(
    id                      int auto_increment
        primary key,
    account                 varchar(32)          not null comment '账号',
    user_name               varchar(32)          not null comment '用户名',
    password                varchar(64)          null comment '用户密码',
    last_login_time         datetime             null comment '上一次登录时间',
    enabled                 tinyint(1) default 1 null comment '账号是否可用。默认为1（可用）',
    not_expired             tinyint(1) default 1 null comment '是否过期。默认为1（没有过期）',
    account_not_locked      tinyint(1) default 1 null comment '账号是否锁定。默认为1（没有锁定）',
    credentials_not_expired tinyint(1) default 1 null comment '证书（密码）是否过期。默认为1（没有过期）',
    create_time             datetime             null comment '创建时间',
    update_time             datetime             null comment '修改时间',
    create_user             int                  null comment '创建人',
    update_user             int                  null comment '修改人'
)
    comment '用户表';

create table sys_role
(
    id               int auto_increment comment '主键id'
        primary key,
    role_name        varchar(32) null comment '角色名',
    role_description varchar(64) null comment '角色说明'
)
    comment '用户角色表';

create table sys_permission
(
    id              int auto_increment comment '主键id'
        primary key,
    permission_code varchar(32) null comment '权限code',
    permission_name varchar(32) null comment '权限名'
)
    comment '权限表';

create table sys_user_role_relation
(
    id      int auto_increment comment '主键id'
        primary key,
    user_id int null comment '用户id',
    role_id int null comment '角色id'
)
    comment '用户角色关联关系表';

create table sys_role_permission_relation
(
    id            int auto_increment comment '主键id'
        primary key,
    role_id       int null comment '角色id',
    permission_id int null comment '权限id'
)
    comment '角色-权限关联关系表';

create table sys_request_path
(
    id          int auto_increment comment '主键id'
        primary key,
    url         varchar(64)  not null comment '请求路径',
    description varchar(128) null comment '路径描述'
)
    comment '请求路径';

create table sys_request_path_permission_relation
(
    id            int null comment '主键id',
    url_id        int null comment '请求路径id',
    permission_id int null comment '权限id'
)
    comment '路径权限关联表';

初始化表数据语句

-- 用户
insert into sys_user (id, account, user_name, password, last_login_time, enabled, account_non_expired, account_non_locked, credentials_non_expired, create_time, update_time, create_user, update_user) values (1, 'user1', '用户1', '$2a$10$47lsfaulwixwg17ca3m/r.epjvib7tv26zaxhzqn65nxvcahhqm4i', '2019-09-04 20:25:36', 1, 1, 1, 1, '2019-08-29 06:28:36', '2019-09-04 20:25:36', 1, 1);
insert into sys_user (id, account, user_name, password, last_login_time, enabled, account_non_expired, account_non_locked, credentials_non_expired, create_time, update_time, create_user, update_user) values (2, 'user2', '用户2', '$2a$10$uslaeon6hwrpbpctyqprj.hvzfem.tivdzm24/grqm4opvze1cvvc', '2019-09-05 00:07:12', 1, 1, 1, 1, '2019-08-29 06:29:24', '2019-09-05 00:07:12', 1, 2);
-- 角色
insert into sys_role (id, role_code, role_name, role_description) values (1, 'admin', '管理员', '管理员，拥有所有权限');
insert into sys_role (id, role_code, role_name, role_description) values (2, 'user', '普通用户', '普通用户，拥有部分权限');
-- 权限
insert into sys_permission (id, permission_code, permission_name) values (1, 'create_user', '创建用户');
insert into sys_permission (id, permission_code, permission_name) values (2, 'query_user', '查看用户');
insert into sys_permission (id, permission_code, permission_name) values (3, 'delete_user', '删除用户');
insert into sys_permission (id, permission_code, permission_name) values (4, 'modify_user', '修改用户');
-- 请求路径
insert into sys_request_path (id, url, description) values (1, '/getuser', '查询用户');
-- 用户角色关联关系
insert into sys_user_role_relation (id, user_id, role_id) values (1, 1, 1);
insert into sys_user_role_relation (id, user_id, role_id) values (2, 2, 2);
-- 角色权限关联关系
insert into sys_role_permission_relation (id, role_id, permission_id) values (1, 1, 1);
insert into sys_role_permission_relation (id, role_id, permission_id) values (2, 1, 2);
insert into sys_role_permission_relation (id, role_id, permission_id) values (3, 1, 3);
insert into sys_role_permission_relation (id, role_id, permission_id) values (4, 1, 4);
insert into sys_role_permission_relation (id, role_id, permission_id) values (5, 2, 1);
insert into sys_role_permission_relation (id, role_id, permission_id) values (6, 2, 2);
-- 请求路径权限关联关系
insert into sys_request_path_permission_relation (id, url_id, permission_id) values (null, 1, 2);

三、spring security核心配置：websecurityconfig

    创建websecurityconfig继承websecurityconfigureradapter类，并实现configure(authenticationmanagerbuilder auth)和 configure(httpsecurity http)方法。后续我们会在里面加入一系列配置，包括配置认证方式、登入登出、异常处理、会话管理等。

@configuration
@enablewebsecurity
public class websecurityconfig extends websecurityconfigureradapter {
    @override
    protected void configure(authenticationmanagerbuilder auth) throws exception {
        //配置认证方式等
        super.configure(auth);
    }

    @override
    protected void configure(httpsecurity http) throws exception {
        //http相关的配置，包括登入登出、异常处理、会话管理等
        super.configure(http);
    }
}

四、用户登录认证逻辑：userdetailsservice

1、创建自定义userdetailsservice

    这是实现自定义用户认证的核心逻辑，loaduserbyusername(string username)的参数就是登录时提交的用户名，返回类型是一个叫userdetails 的接口，需要在这里构造出他的一个实现类user，这是spring security提供的用户信息实体。

public class userdetailsserviceimpl  implements userdetailsservice {
    @override
    public userdetails loaduserbyusername(string username) throws usernamenotfoundexception {
        //需要构造出 org.springframework.security.core.userdetails.user 对象并返回
        return null;
    }
}

    这里我们使用他的一个参数比较详细的构造函数，源码如下

user(string username, string password, boolean enabled, boolean accountnonexpired, boolean credentialsnonexpired, boolean accountnonlocked, collection<? extends grantedauthority> authorities)

其中参数：

string username：用户名
string password： 密码
boolean enabled： 账号是否可用
boolean accountnonexpired：账号是否过期
boolean credentialsnonexpired：密码是否过期
boolean accountnonlocked：账号是否锁定
collection<? extends grantedauthority> authorities)：用户权限列表

    这就与我们的创建的用户表的字段对应起来了，spring security都为我们封装好了，如果用户信息的状态异常，登录时则会抛出相应的异常，根据捕获到的异常判断是什么原因（账号过期/密码过期/账号锁定等等…），进而就可以提示前台了。
    我们就按照该参数列表构造出我们所需要的数据，然后返回，就完成了基于jdbc的自定义用户认证。
    首先用户名密码以及用户状态信息都是从用户表里进行单表查询来的，而权限列表则是通过用户表、角色表以及权限表等关联查出来的，那么接下来就是准备service和dao层方法了

2、准备service和dao层方法

（1）根据用户名查询用户信息

映射文件

    <!--根据用户名查询用户-->
    <select id="selectbyname" resultmap="sysusermap">
        select * from sys_user where account = #{username};
    </select>

service层

    /**
     * 根据用户名查询用户
     *
     * @param username
     * @return
     */
    sysuser selectbyname(string username);

（2）根据用户名查询用户的权限信息

映射文件

    <select id="selectlistbyuser" resultmap="syspermissionmap">
        select
        p.*
        from
        sys_user as u
        left join sys_user_role_relation as ur
        on u.id = ur.user_id
        left join sys_role as r
        on r.id = ur.role_id
        left join sys_role_permission_relation as rp
        on r.id = rp.role_id
        left join sys_permission as p
        on p.id = rp.permission_id
        where u.id = #{userid}
    </select>

service层

    /**
     * 查询用户的权限列表
     *
     * @param userid
     * @return
     */
    list<syspermission> selectlistbyuser(integer userid);

    这样的话流程我们就理清楚了，首先根据用户名查出对应用户，再拿得到的用户的用户id去查询它所拥有的的权限列表，最后构造出我们需要的org.springframework.security.core.userdetails.user对象。
接下来改造一下刚刚自定义的userdetailsservice

public class userdetailsserviceimpl implements userdetailsservice {
    @autowired
    private sysuserservice sysuserservice;
    @autowired
    private syspermissionservice syspermissionservice;

    @override
    public userdetails loaduserbyusername(string username) throws usernamenotfoundexception {
        if (username == null || "".equals(username)) {
            throw new runtimeexception("用户不能为空");
        }
        //根据用户名查询用户
        sysuser sysuser = sysuserservice.selectbyname(username);
        if (sysuser == null) {
            throw new runtimeexception("用户不存在");
        }
        list<grantedauthority> grantedauthorities = new arraylist<>();
        if (sysuser != null) {
            //获取该用户所拥有的权限
            list<syspermission> syspermissions = syspermissionservice.selectlistbyuser(sysuser.getid());
            // 声明用户授权
            syspermissions.foreach(syspermission -> {
                grantedauthority grantedauthority = new simplegrantedauthority(syspermission.getpermissioncode());
                grantedauthorities.add(grantedauthority);
            });
        }
        return new user(sysuser.getaccount(), sysuser.getpassword(), sysuser.getenabled(), sysuser.getaccountnonexpired(), sysuser.getcredentialsnonexpired(), sysuser.getaccountnonlocked(), grantedauthorities);
    }
}

    然后将我们的自定义的基于jdbc的用户认证在之前创建的websecurityconfig 中得configure(authenticationmanagerbuilder auth)中声明一下，到此自定义的基于jdbc的用户认证就完成了

    @bean
    public userdetailsservice userdetailsservice() {
        //获取用户账号密码及权限信息
        return new userdetailsserviceimpl();
    }

    @override
    protected void configure(authenticationmanagerbuilder auth) throws exception {
        //配置认证方式
        auth.userdetailsservice(userdetailsservice());
    }

五、用户密码加密

    新版本的spring security规定必须设置一个默认的加密方式，不允许使用明文。这个加密方式是用于在登录时验证密码、注册时需要用到。

    我们可以自己选择一种加密方式，spring security为我们提供了多种加密方式，我们这里使用一种强hash方式进行加密。

   

 在websecurityconfig 中注入（注入即可，不用声明使用），这样就会对提交的密码进行加密处理了，如果你没有注入加密方式，运行的时候会报错"there is no passwordencoder mapped for the id"错误。

    @bean
    public bcryptpasswordencoder passwordencoder() {
        // 设置默认的加密方式（强hash方式加密）
        return new bcryptpasswordencoder();
    }

    同样的我们数据库里存储的密码也要用同样的加密方式存储，例如我们将123456用bcryptpasswordencoder 加密后存储到数据库中（注意：即使是同一个明文用这种加密方式加密出来的密文也是不同的，这就是这种加密方式的特点）

六、屏蔽spring security默认重定向登录页面以实现前后端分离功能

    在演示登录之前我们先编写一个查询接口"/getuser"，并将"/getuser"接口规定为需要拥有"query_user"权限的用户可以访问，并在角色-权限关联关系表中给user1用户所属角色（role_id = 1）添加权限"query_user"

    然后规定接口"/getuser"只能是拥有"query_user"权限的用户可以访问。后面我们基本都用这个查询接口作为演示，就叫它"资源接口"吧。

http.authorizerequests().
       antmatchers("/getuser").hasauthority("query_user").

    演示登录时，如果用户没有登录去请求资源接口就会提示未登录

    在前后端不分离的时候当用户未登录去访问资源时spring security会重定向到默认的登录页面，返回的是一串html标签，这一串html标签其实就是登录页面的提交表单。如图所示

 

   而在前后端分离的情况下（比如前台使用vue或jq等）我们需要的是在前台接收到"用户未登录"的提示信息，所以我们接下来要做的就是屏蔽重定向的登录页面，并返回统一的json格式的返回体。而实现这一功能的核心就是实现authenticationentrypoint并在websecurityconfig中注入，然后在configure(httpsecurity http)方法中。authenticationentrypoint主要是用来处理匿名用户访问无权限资源时的异常（即未登录，或者登录状态过期失效）

/**
 * @author: hutengfei
 * @description: 匿名用户访问无权限资源时的异常
 * @date create in 2019/9/3 21:35
 */
@component
public class customizeauthenticationentrypoint implements authenticationentrypoint {
    @override
    public void commence(httpservletrequest httpservletrequest, httpservletresponse httpservletresponse, authenticationexception e) throws ioexception, servletexception {
        jsonresult result = resulttool.fail(resultcode.user_not_login);
        httpservletresponse.setcontenttype("text/json;charset=utf-8");
        httpservletresponse.getwriter().write(json.tojsonstring(result));
    }
}

在websecurityconfig中的configure(httpsecurity http)方法中声明

 //异常处理(权限拒绝、登录失效等)
 and().exceptionhandling().
 authenticationentrypoint(authenticationentrypoint).//匿名用户访问无权限资源时的异常处理

再次请求资源接口

前台拿到这个错误时就可以做一些处理了，主要是退出到登录页面。

1、实现登录成功/失败、登出处理逻辑

    首先需要明白一件事，对于登入登出我们都不需要自己编写controller接口，spring security为我们封装好了。默认登入路径:/login，登出路径:/logout。当然我们可以也修改默认的名字。登录成功失败和登出的后续处理逻辑如何编写会在后面慢慢解释。
    当登录成功或登录失败都需要返回统一的json返回体给前台，前台才能知道对应的做什么处理。
而实现登录成功和失败的异常处理需要分别实现authenticationsuccesshandler和authenticationfailurehandler接口并在websecurityconfig中注入，然后在configure(httpsecurity http)方法中然后声明

（1）登录成功

/**
 * @author: hutengfei
 * @description: 登录成功处理逻辑
 * @date create in 2019/9/3 15:52
 */
@component
public class customizeauthenticationsuccesshandler implements authenticationsuccesshandler {
    @autowired
    sysuserservice sysuserservice;

    @override
    public void onauthenticationsuccess(httpservletrequest httpservletrequest, httpservletresponse httpservletresponse, authentication authentication) throws ioexception, servletexception {
        //更新用户表上次登录时间、更新人、更新时间等字段
        user userdetails = (user)securitycontextholder.getcontext().getauthentication().getprincipal();
        sysuser sysuser = sysuserservice.selectbyname(userdetails.getusername());
        sysuser.setlastlogintime(new date());
        sysuser.setupdatetime(new date());
        sysuser.setupdateuser(sysuser.getid());
        sysuserservice.update(sysuser);
        
        //此处还可以进行一些处理，比如登录成功之后可能需要返回给前台当前用户有哪些菜单权限，
        //进而前台动态的控制菜单的显示等，具体根据自己的业务需求进行扩展

        //返回json数据
        jsonresult result = resulttool.success();
       //处理编码方式，防止中文乱码的情况
        httpservletresponse.setcontenttype("text/json;charset=utf-8");
       //塞到httpservletresponse中返回给前台
        httpservletresponse.getwriter().write(json.tojsonstring(result));
    }
}

（2）登录失败

登录失败处理器主要用来对登录失败的场景（密码错误、账号锁定等…）做统一处理并返回给前台统一的json返回体。还记得我们创建用户表的时候创建了账号过期、密码过期、账号锁定之类的字段吗，这里就可以派上用场了.

/**
 * @author: hutengfei
 * @description: 登录失败处理逻辑
 * @date create in 2019/9/3 15:52
 */
@component
public class customizeauthenticationfailurehandler implements authenticationfailurehandler {


    @override
    public void onauthenticationfailure(httpservletrequest httpservletrequest, httpservletresponse httpservletresponse, authenticationexception e) throws ioexception, servletexception {
        //返回json数据
        jsonresult result = null;
        if (e instanceof accountexpiredexception) {
            //账号过期
            result = resulttool.fail(resultcode.user_account_expired);
        } else if (e instanceof badcredentialsexception) {
            //密码错误
            result = resulttool.fail(resultcode.user_credentials_error);
        } else if (e instanceof credentialsexpiredexception) {
            //密码过期
            result = resulttool.fail(resultcode.user_credentials_expired);
        } else if (e instanceof disabledexception) {
            //账号不可用
            result = resulttool.fail(resultcode.user_account_disable);
        } else if (e instanceof lockedexception) {
            //账号锁定
            result = resulttool.fail(resultcode.user_account_locked);
        } else if (e instanceof internalauthenticationserviceexception) {
            //用户不存在
            result = resulttool.fail(resultcode.user_account_not_exist);
        }else{
            //其他错误
            result = resulttool.fail(resultcode.common_fail);
        }
       //处理编码方式，防止中文乱码的情况
        httpservletresponse.setcontenttype("text/json;charset=utf-8");
       //塞到httpservletresponse中返回给前台
        httpservletresponse.getwriter().write(json.tojsonstring(result));
    }
}

（3）登出

同样的登出也要将登出成功时结果返回给前台，并且登出之后进行将cookie失效或删除

/**
 * @author: hutengfei
 * @description: 登出成功处理逻辑
 * @date create in 2019/9/4 10:17
 */
@component
public class customizelogoutsuccesshandler implements logoutsuccesshandler {
    @override
    public void onlogoutsuccess(httpservletrequest httpservletrequest, httpservletresponse httpservletresponse, authentication authentication) throws ioexception, servletexception {
        jsonresult result = resulttool.success();
        httpservletresponse.setcontenttype("text/json;charset=utf-8");
        httpservletresponse.getwriter().write(json.tojsonstring(result));
    }
}

2、在websecurityconfig中的configure(httpsecurity http)方法中声明

//登入
and().formlogin().
	permitall().//允许所有用户
	successhandler(authenticationsuccesshandler).//登录成功处理逻辑
	failurehandler(authenticationfailurehandler).//登录失败处理逻辑

//登出
and().logout().
	permitall().//允许所有用户
	logoutsuccesshandler(logoutsuccesshandler).//登出成功处理逻辑
	deletecookies("jsessionid").//登出之后删除cookie

效果如图：

登录时密码错误

登录时账号被锁定

退出登录之后再次请求资源接口

八、会话管理（登录过时、限制单用户或多用户登录等）

1、限制登录用户数量

比如限制同一账号只能一个用户使用

and().sessionmanagement().
                    maximumsessions(1)

2、处理账号被挤下线处理逻辑

同样的，当账号异地登录导致被挤下线时也要返回给前端json格式的数据，比如提示"账号下线"、"您的账号在异地登录，是否是您自己操作"或者"您的账号在异地登录,可能由于密码泄露，建议修改密码"等。这时就要实现sessioninformationexpiredstrategy（会话信息过期策略）来自定义会话过期时的处理逻辑。

/**
 * @author: hutengfei
 * @description: 会话信息过期策略
 * @date create in 2019/9/4 9:34
 */
@component
public class customizesessioninformationexpiredstrategy implements sessioninformationexpiredstrategy {
    @override
    public void onexpiredsessiondetected(sessioninformationexpiredevent sessioninformationexpiredevent) throws ioexception, servletexception {
        jsonresult result = resulttool.fail(resultcode.user_account_use_by_others);
        httpservletresponse httpservletresponse = sessioninformationexpiredevent.getresponse();
        httpservletresponse.setcontenttype("text/json;charset=utf-8");
        httpservletresponse.getwriter().write(json.tojsonstring(result));
    }
}

3、在websecurityconfig中声明

然后需要在websecurityconfig中注入，并在configure(httpsecurity http)方法中然后声明，在配置同时登录用户数的配置下面再加一行 expiredsessionstrategy(sessioninformationexpiredstrategy)

//会话管理
and().sessionmanagement().
	maximumsessions(1).//同一账号同时登录最大用户数
	expiredsessionstrategy(sessioninformationexpiredstrategy);//会话信息过期策略会话信息过期策略(账号被挤下线)

效果演示步骤
我电脑上用postman登录
我电脑上请求资源接口，可以请求，如下左图
在旁边电脑上再登录一次刚刚的账号
在我电脑上再次请求资源接口，提示"账号下线"，如右下图

九、实现基于jdbc的动态权限控制

在之前的章节中我们配置了一个

antmatchers("/getuser").hasauthority("query_user")

    其实我们就已经实现了一个所谓的基于rbac的权限控制，只不过我们是在websecurityconfig中写死的，但是在平时开发中，难道我们每增加一个需要访问权限控制的资源我们都要修改一下websecurityconfig增加一个antmatchers(…)吗，肯定是不合理的。因此我们现在要做的就是将需要权限控制的资源配到数据库中，当然也可以存储在其他地方，比如用一个枚举，只是我觉得存在数据库中更加灵活一点。

    我们需要实现一个accessdecisionmanager（访问决策管理器），在里面我们对当前请求的资源进行权限判断，判断当前登录用户是否拥有该权限，如果有就放行，如果没有就抛出一个"权限不足"的异常。不过在实现accessdecisionmanager之前我们还需要做一件事，那就是拦截到当前的请求，并根据请求路径从数据库中查出当前资源路径需要哪些权限才能访问，然后将查出的需要的权限列表交给accessdecisionmanager去处理后续逻辑。那就是需要先实现一个securitymetadatasource，翻译过来是"安全元数据源"，我们这里使用他的一个子类filterinvocationsecuritymetadatasource。

    在自定义的securitymetadatasource编写好之后，我们还要编写一个拦截器，增加到spring security默认的拦截器链中，以达到拦截的目的。

    同样的最后需要在websecurityconfig中注入，并在configure(httpsecurity http)方法中然后声明

1、权限拦截器

/**
 * @author: hutengfei
 * @description: 权限拦截器
 * @date create in 2019/9/4 16:25
 */
@service
public class customizeabstractsecurityinterceptor extends abstractsecurityinterceptor implements filter {

    @autowired
    private filterinvocationsecuritymetadatasource securitymetadatasource;

    @autowired
    public void setmyaccessdecisionmanager(customizeaccessdecisionmanager accessdecisionmanager) {
        super.setaccessdecisionmanager(accessdecisionmanager);
    }

    @override
    public class<?> getsecureobjectclass() {
        return filterinvocation.class;
    }

    @override
    public securitymetadatasource obtainsecuritymetadatasource() {
        return this.securitymetadatasource;
    }

    @override
    public void dofilter(servletrequest servletrequest, servletresponse servletresponse, filterchain filterchain) throws ioexception, servletexception {
        filterinvocation fi = new filterinvocation(servletrequest, servletresponse, filterchain);
        invoke(fi);
    }

    public void invoke(filterinvocation fi) throws ioexception, servletexception {
        //fi里面有一个被拦截的url
        //里面调用myinvocationsecuritymetadatasource的getattributes(object object)这个方法获取fi对应的所有权限
        //再调用myaccessdecisionmanager的decide方法来校验用户的权限是否足够
        interceptorstatustoken token = super.beforeinvocation(fi);
        try {
        //执行下一个拦截器
            fi.getchain().dofilter(fi.getrequest(), fi.getresponse());
        } finally {
            super.afterinvocation(token, null);
        }
    }
}

2、安全元数据源filterinvocationsecuritymetadatasource

/**
 * @author: hutengfei
 * @description:
 * @date create in 2019/9/3 21:06
 */
@component
public class customizefilterinvocationsecuritymetadatasource implements filterinvocationsecuritymetadatasource {
    antpathmatcher antpathmatcher = new antpathmatcher();
    @autowired
    syspermissionservice syspermissionservice;
    @override
    public collection<configattribute> getattributes(object o) throws illegalargumentexception {
        //获取请求地址
        string requesturl = ((filterinvocation) o).getrequesturl();
        //查询具体某个接口的权限
        list<syspermission> permissionlist =  syspermissionservice.selectlistbypath(requesturl);
        if(permissionlist == null || permissionlist.size() == 0){
            //请求路径没有配置权限，表明该请求接口可以任意访问
            return null;
        }
        string[] attributes = new string[permissionlist.size()];
        for(int i = 0;i<permissionlist.size();i++){
            attributes[i] = permissionlist.get(i).getpermissioncode();
        }
        return securityconfig.createlist(attributes);
    }

    @override
    public collection<configattribute> getallconfigattributes() {
        return null;
    }

    @override
    public boolean supports(class<?> aclass) {
        return true;
    }
}

3、访问决策管理器accessdecisionmanager

/**
 * @author: hutengfei
 * @description: 访问决策管理器
 * @date create in 2019/9/3 20:38
 */
@component
public class customizeaccessdecisionmanager implements accessdecisionmanager {
    @override
    public void decide(authentication authentication, object o, collection<configattribute> collection) throws accessdeniedexception, insufficientauthenticationexception {
        iterator<configattribute> iterator = collection.iterator();
        while (iterator.hasnext()) {
            configattribute ca = iterator.next();
            //当前请求需要的权限
            string needrole = ca.getattribute();
            //当前用户所具有的权限
            collection<? extends grantedauthority> authorities = authentication.getauthorities();
            for (grantedauthority authority : authorities) {
                if (authority.getauthority().equals(needrole)) {
                    return;
                }
            }
        }
        throw new accessdeniedexception("权限不足!");
    }

    @override
    public boolean supports(configattribute configattribute) {
        return true;
    }

    @override
    public boolean supports(class<?> aclass) {
        return true;
    }
}

4、在websecurityconfig中声明

先在websecurityconfig中注入，并在configure(httpsecurity http)方法中然后声明

        http.authorizerequests().
                withobjectpostprocessor(new objectpostprocessor<filtersecurityinterceptor>() {
                    @override
                    public <o extends filtersecurityinterceptor> o postprocess(o o) {
                        o.setaccessdecisionmanager(accessdecisionmanager);//访问决策管理器
                        o.setsecuritymetadatasource(securitymetadatasource);//安全元数据源
                        return o;
                    }
                });
        http.addfilterbefore(securityinterceptor, filtersecurityinterceptor.class);//增加到默认拦截链中

十、最终的websecurityconfig配置

/**
 * @author: hutengfei
 * @description:
 * @date create in 2019/8/28 20:15
 */
@configuration
@enablewebsecurity
public class websecurityconfig extends websecurityconfigureradapter {
    //登录成功处理逻辑
    @autowired
    customizeauthenticationsuccesshandler authenticationsuccesshandler;

    //登录失败处理逻辑
    @autowired
    customizeauthenticationfailurehandler authenticationfailurehandler;

    //权限拒绝处理逻辑
    @autowired
    customizeaccessdeniedhandler accessdeniedhandler;

    //匿名用户访问无权限资源时的异常
    @autowired
    customizeauthenticationentrypoint authenticationentrypoint;

    //会话失效(账号被挤下线)处理逻辑
    @autowired
    customizesessioninformationexpiredstrategy sessioninformationexpiredstrategy;

    //登出成功处理逻辑
    @autowired
    customizelogoutsuccesshandler logoutsuccesshandler;

    //访问决策管理器
    @autowired
    customizeaccessdecisionmanager accessdecisionmanager;

    //实现权限拦截
    @autowired
    customizefilterinvocationsecuritymetadatasource securitymetadatasource;

    @autowired
    private customizeabstractsecurityinterceptor securityinterceptor;

    @bean
    public userdetailsservice userdetailsservice() {
        //获取用户账号密码及权限信息
        return new userdetailsserviceimpl();
    }

    @bean
    public bcryptpasswordencoder passwordencoder() {
        // 设置默认的加密方式（强hash方式加密）
        return new bcryptpasswordencoder();
    }

    @override
    protected void configure(authenticationmanagerbuilder auth) throws exception {
        auth.userdetailsservice(userdetailsservice());
    }

    @override
    protected void configure(httpsecurity http) throws exception {
        http.cors().and().csrf().disable();
        http.authorizerequests().
                //antmatchers("/getuser").hasauthority("query_user").
                //antmatchers("/**").fullyauthenticated().
                withobjectpostprocessor(new objectpostprocessor<filtersecurityinterceptor>() {
                    @override
                    public <o extends filtersecurityinterceptor> o postprocess(o o) {
                        o.setaccessdecisionmanager(accessdecisionmanager);//决策管理器
                        o.setsecuritymetadatasource(securitymetadatasource);//安全元数据源
                        return o;
                    }
                }).
                //登出
                and().logout().
                    permitall().//允许所有用户
                    logoutsuccesshandler(logoutsuccesshandler).//登出成功处理逻辑
                    deletecookies("jsessionid").//登出之后删除cookie
                //登入
                and().formlogin().
                    permitall().//允许所有用户
                    successhandler(authenticationsuccesshandler).//登录成功处理逻辑
                    failurehandler(authenticationfailurehandler).//登录失败处理逻辑
                //异常处理(权限拒绝、登录失效等)
                and().exceptionhandling().
                    accessdeniedhandler(accessdeniedhandler).//权限拒绝处理逻辑
                    authenticationentrypoint(authenticationentrypoint).//匿名用户访问无权限资源时的异常处理
                //会话管理
                and().sessionmanagement().
                    maximumsessions(1).//同一账号同时登录最大用户数
                    expiredsessionstrategy(sessioninformationexpiredstrategy);//会话失效(账号被挤下线)处理逻辑
        http.addfilterbefore(securityinterceptor, filtersecurityinterceptor.class);
    }
}

十一、结束语

到现在为止本文就基本结束了，在本文中我们利用springboot+spring security实现了前后端分离的用户登录认证和动态的权限访问控制。

最后附上github地址：
github

到此这篇关于springboot+spring security实现前后端分离登录认证及权限控制的示例代码的文章就介绍到这了,更多相关springboot springsecurity前后端分离登录认证内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！