【笔记】SpringBoot+Shiro 实现简单权限管理(使用mysql数据库)

网上翻了好久 都没有SpringBoot+Shiro的入门教程 原本想看《跟我学Shiro》

然后发现这是从头开始 但是我就需要和SpringBoot整一块 不需要那么多的东西 感觉这个当参考书不错

于是东拼西凑终于整成了 把别人的教程上我用不到的都删了 该改的改 终于拿到了我理想中的效果

先是数据库部分 因为是简单的实现 就没有弄得太复杂

三部分 用户 -- 角色 -- 权限

四张表

用户和角色是多对一的关系(多对多懒得弄...)

角色和权限是多对多的关系(这个没啥好说的)

直接放代码了 那个url忽略就好了 完全没用上 我打算弄菜单的自动获取能访问的列表 这样就不用写死了

DROP TABLE IF EXISTS tb_user;
CREATE TABLE tb_user (
  `id`          INT PRIMARY KEY NOT NULL AUTO_INCREMENT,
  `username`    VARCHAR(50)     NOT NULL UNIQUE KEY,
  `password`    VARCHAR(255)    NOT NULL,
  `role_id`     INT             NOT NULL,
  `create_time` DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time` DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP
);

DROP TABLE IF EXISTS tb_role;
CREATE TABLE tb_role (
  `id`          INT PRIMARY KEY NOT NULL AUTO_INCREMENT,
  `name`        VARCHAR(50)     NOT NULL UNIQUE KEY,
  `desc`        VARCHAR(50)     NOT NULL,
  `create_time` DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time` DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP
);

DROP TABLE IF EXISTS tb_permission;
CREATE TABLE tb_permission (
  `id`          INT PRIMARY KEY NOT NULL AUTO_INCREMENT,
  `parent_id`   INT,
  `name`        VARCHAR(50)     NOT NULL UNIQUE KEY,
  `desc`        VARCHAR(50)     NOT NULL,
  `url`         VARCHAR(255)    NOT NULL DEFAULT '#',
  `order_by`    INT,
  `type`        INT             NOT NULL DEFAULT 0,
  `create_time` DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time` DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP
);

DROP TABLE IF EXISTS tb_role_permission;
CREATE TABLE tb_role_permission (
  `id`            INT PRIMARY KEY NOT NULL AUTO_INCREMENT,
  `role_id`       INT             NOT NULL,
  `permission_id` INT             NOT NULL,
  `create_time`   DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time`   DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO tb_permission (`id`, `name`, `desc`, url, `order_by`, `type`)
VALUES ('1', 'user:*', '用户管理', '/getAll', '1', '1');
INSERT INTO tb_permission (`id`, `name`, `desc`, url, `order_by`, `type`)
VALUES ('2', 'user:query', '查询用户', '#', '1', '1');
INSERT INTO tb_permission (`id`, `name`, `desc`, url, `order_by`, `type`)
VALUES ('3', 'user:insert', '新增用户', '#', '1', '1');
INSERT INTO tb_permission (`id`, `name`, `desc`, url, `order_by`, `type`)
VALUES ('4', 'user:update', '修改用户', '#', '1', '1');
INSERT INTO tb_permission (`id`, `name`, `desc`, url, `order_by`, `type`)
VALUES ('5', 'user:delete', '删除用户', '#', '1', '1');

INSERT INTO tb_role (`id`, `name`, `desc`) VALUES ('1', 'admin', '系统管理员');
INSERT INTO tb_role (`id`, `name`, `desc`) VALUES ('2', 'users', '普通用户');

INSERT INTO tb_role_permission (`role_id`, `permission_id`) VALUES ('1', '1');
INSERT INTO tb_role_permission (`role_id`, `permission_id`) VALUES ('2', '2');

INSERT INTO tb_user (`id`, `username`, `password`, `role_id`) VALUES ('1', 'admin', 'admin', '1');
INSERT INTO tb_user (`id`, `username`, `password`, `role_id`) VALUES ('2', 'user1', '123456', '2');

这块设置了俩角色 管理组和用户组 管理组有查询权限 用户组没有查询权限

数据库整完之后就是java部分 先上依赖

<properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    <spring.version>2.2.6.RELEASE</spring.version>
    <nekohtml.version>1.9.22</nekohtml.version>
    <jdbc.version>8.0.16</jdbc.version>
    <druid.version>1.1.10</druid.version>
    <mybatis-spring.version>1.3.0</mybatis-spring.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <exclusions>
            <exclusion>
                <artifactId>spring-boot-starter-tomcat</artifactId>
                <groupId>org.springframework.boot</groupId>
            </exclusion>
        </exclusions>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.0</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${jdbc.version}</version>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>${mybatis-spring.version}</version>
    </dependency>

    <!-- thymeleaf网页解析 -->
    <dependency>
        <groupId>net.sourceforge.nekohtml</groupId>
        <artifactId>nekohtml</artifactId>
        <version>${nekohtml.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

springboot的配置文件 现在咋都好用yml了 properties多好 yml还要考虑缩进

server:
    port: 8080
    tomcat:
        uri-encoding: utf-8

spring:
    thymeleaf:
        mode: LEGACYHTML5
        cache: false
    datasource:
        url: jdbc:mysql://localhost/db_test
        username: test
        password: test
        driver-class-name: com.mysql.cj.jdbc.Driver
        type: com.alibaba.druid.pool.DruidDataSource

mybatis:
    typeAliasesPackage: cn.erika.user.model
    mapper-locations: classpath:static/mybatis/*Mapper.xml

shiro:
    url:
        login: login
        index: index
        unauthorized: login
    session:
        timeout: 30
        validationInterval: 15
    cookie:
        domain:
        path: /
        timeout: 7

shiro部分除了url 其他的都没用上 但还是配上了

鉴权的数据来自与数据库 所以首先要把数据查询部分搞好

mybatis咋玩在这就不写了 在这个实验性质的程序上 至少要实现根据用户查角色和根据用户查权限

我的一个用户只有一个角色 所以根据用户名查到用户就行

查到用户之后就可以根据用户查权限 这是服务层的这个方法的签名

public Set<String> getPermissionsByUserId(Integer userId);

返回值是字符串的set集 注意是set 我习惯性的返回list之后 写realm的时候发现他只接受set

下面这些都是shiro相关的代码 需要自己去实现的部分

package cn.erika.shiro.realm;

import cn.erika.user.model.User;
import cn.erika.user.service.IUserService;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 这个就是认证的实现类
 * 你得自己去实现如何去认证
 * 这里实现了使用用户名和密码进行认证
 */
@Component
public class UserRealm extends AuthorizingRealm {

    @Autowired
    private IUserService userService;

    // 这块是权限鉴定 就是登录成功后把权限查出来
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 首先要把用户查出来
        User user = userService.getUserByUsername(principalCollection.toString());
        // 然后把他的角色和权限查出来 扔进
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.setRoles(user.getRoleNames());
        info.setStringPermissions(userService.getPermissionsByUserId(user.getId()));
        return info;
    }

    // 这块是身份鉴定 相当于登录
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        User user = userService.getUserByUsername(token.getUsername());
        // 我这块就写了一个异常
        if (user == null) {
            throw new UnknownAccountException();
        }
        // 实际上有好些异常可以往外抛
        // IncorrectCredentialsException 凭证错误 可以理解为密码错误
        // DisabledAccountException 账号被禁用
        // LockedAccountException 账号被锁定
        // ExcessiveAttemptsException 登录失败次数超过限制
        // ... 还有好些 他们都是 AuthenticationException的子类

        // 这里返回一个认证信息
        return new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName());
    }
}

Shiro的配置

package cn.erika.shiro;

import cn.erika.shiro.realm.UserRealm;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

@Configuration
public class ShiroConfig {
    // 登录页面的URL
    @Value("${shiro.url.login}")
    private String loginUrl;

    // 主页URL 认证成功会跳到这里
    @Value("${shiro.url.index}")
    private String indexUrl;

    // 认证失败的URL 我这里其实还是跳到了登录页面
    @Value("${shiro.url.unauthorized}")
    private String unauthorizedUrl;

    @Bean
    public SecurityManager securityManager(UserRealm userRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(userRealm);
        return securityManager;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(securityManager);
        factoryBean.setLoginUrl(loginUrl);
        factoryBean.setUnauthorizedUrl(unauthorizedUrl);

        HashMap<String, String> filterChain = new HashMap<>();
        filterChain.put("/favicon.ico", "anon");
        filterChain.put("/login", "anon");

        filterChain.put("/logout", "logout");
        filterChain.put("/**","authc");

        factoryBean.setFilterChainDefinitionMap(filterChain);

        return factoryBean;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
}

这是控制器

package cn.erika.user.controller;

import cn.erika.user.dao.UserDao;
import cn.erika.user.model.User;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import java.util.List;

@Controller
public class UserController {

    @Autowired
    private UserDao userDao;

    @RequestMapping({"", "index"})
    public String index() {
        return "index";
    }

    @RequiresPermissions("user:query")
    @RequestMapping("/users")
    @ResponseBody
    public List<User> getUsers() {
        return userDao.getUsers();
    }

    @GetMapping("/login")
    public String loginFrom() {
        return "login";
    }

    @PostMapping("/login")
    public String login(User user) {
        String username = user.getUsername();
        System.out.println("用户名: " + username);
        UsernamePasswordToken token = new UsernamePasswordToken(username, user.getPassword());

        Subject subject = SecurityUtils.getSubject();
        try {
            System.out.println("登录验证: " + username);
            subject.login(token);
            System.out.println("验证通过: " + username);
        } catch (UnknownAccountException e) {
            System.err.println("未知的账户");
        } catch (IncorrectCredentialsException e) {
            System.err.println("密码错误");
        } catch (AuthenticationException e) {
            System.err.println("其他错误");
            e.printStackTrace();
        }
        if (subject.isAuthenticated()) {
            System.out.println("登录成功");
            return "redirect:/index";
        } else {
            token.clear();
            return "redirect:/login";
        }
    }

    @GetMapping("/logout")
    public String logout(RedirectAttributes redirectAttributes) {
        SecurityUtils.getSubject().logout();
        redirectAttributes.addFlashAttribute("message", "退出登录");
        return "redirect:/login";
    }


}

页面我就不放了 没啥看头

主页就是俩按钮 一个指向users 一个指向logout

登录页面就是用户名和密码 指向login

其实到这里功能已经实现了 登录和权限鉴定都有了

但是很不美 因为如果没有权限 他直接蹦403 你要是ajax肯定不爽

所以搞了一下Spring的异常统一处理 捕获了一下AuthorizationException异常 这样就舒服了

package cn.erika.exception;

import cn.erika.model.Message;
import org.apache.shiro.authz.AuthorizationException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class DefaultExceptionHandler {

    @ExceptionHandler(AuthorizationException.class)
    public Message authorizationException(AuthorizationException e) {
        return Message.failed("没有操作权限");
    }
}

那个Message类就俩属性

int code;

String message;

我写了一堆静态方法方便调用 不用每次都要填错误信息了

我用user1登录后 查询用户信息 就会返回这条信息

开发的时候还是火狐好用 自带json格式化和上色 这多舒服

数据少的不明显 你看看数据多的时候 

这是谷歌的

 这是火狐的

 忘了说了 我user里面roleNames这个属性是为了图省事 不然就得调 user.getRole().getName(); 总觉得这样用的不爽