Spring Boot整合Shiro实现用户身份认证和权限认证

最新推荐文章于 2024-06-25 16:02:04 发布

大何向东流1997

最新推荐文章于 2024-06-25 16:02:04 发布

阅读量1.2k

点赞数 2

分类专栏： Spring Boot 文章标签： shiro SpringBoot

本文链接：https://blog.csdn.net/h2503652646/article/details/108019756

版权

Spring Boot 专栏收录该内容

6 篇文章 5 订阅

订阅专栏

至于Shiro的概念和功能就不再过多赘述，这些在网上都能查到。我们直接进入整合Shiro的正题。

本文强调Shiro的整合而不强调SpringBoot框架的搭建，如需了解请跳转：Spring Boot+Mybatis+thymeleaf整合

一、项目结构

二、数据库表准备

准备五张表：用户表(user_tb)、角色表(role_tb)、权限表(permissions_tb)、用户角色表(user_role)、角色权限表(role_permissions)。

我们往表中添加三个用户，两个角色admin和user，两种权限read和edit。

第一个用户分配admin角色，分配read、edit权限。

第二个用户分配user角色，分配read权限。

第三个用户暂不分配角色。

/*
Navicat MySQL Data Transfer

Source Server         : localhost_3306
Source Server Version : 50642
Source Host           : localhost:3306
Source Database       : shiro_demo

Target Server Type    : MYSQL
Target Server Version : 50642
File Encoding         : 65001

Date: 2020-08-15 11:15:20
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for permissions_tb
-- ----------------------------
DROP TABLE IF EXISTS `permissions_tb`;
CREATE TABLE `permissions_tb` (
  `permid` varchar(11) NOT NULL,
  `permissionsName` varchar(255) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of permissions_tb
-- ----------------------------
INSERT INTO `permissions_tb` VALUES ('1', 'read');
INSERT INTO `permissions_tb` VALUES ('2', 'edit');

-- ----------------------------
-- Table structure for role_permissions
-- ----------------------------
DROP TABLE IF EXISTS `role_permissions`;
CREATE TABLE `role_permissions` (
  `roleid` varchar(11) NOT NULL,
  `permid` varchar(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of role_permissions
-- ----------------------------
INSERT INTO `role_permissions` VALUES ('1', '1');
INSERT INTO `role_permissions` VALUES ('1', '2');
INSERT INTO `role_permissions` VALUES ('2', '1');

-- ----------------------------
-- Table structure for role_tb
-- ----------------------------
DROP TABLE IF EXISTS `role_tb`;
CREATE TABLE `role_tb` (
  `roleid` varchar(11) NOT NULL,
  `roleName` varchar(255) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of role_tb
-- ----------------------------
INSERT INTO `role_tb` VALUES ('1', 'admin');
INSERT INTO `role_tb` VALUES ('2', 'user');

-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
  `userid` varchar(11) NOT NULL,
  `roleid` varchar(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user_role
-- ----------------------------
INSERT INTO `user_role` VALUES ('1', '1');
INSERT INTO `user_role` VALUES ('2', '2');

-- ----------------------------
-- Table structure for user_tb
-- ----------------------------
DROP TABLE IF EXISTS `user_tb`;
CREATE TABLE `user_tb` (
  `userid` varchar(11) NOT NULL,
  `password` varchar(255) NOT NULL,
  `username` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`userid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user_tb
-- ----------------------------
INSERT INTO `user_tb` VALUES ('1', '123', '周杰伦');
INSERT INTO `user_tb` VALUES ('2', '123', '张无忌');
INSERT INTO `user_tb` VALUES ('3', '123', '赵敏');

三、测试页面准备

下面是我们需要准备的测试页面,页面中不用真的去获取用户数据，只需要打印一句话证明我们进入到该页面就行了。

login.html：登陆页面，没有登陆的用户访问需要登陆的页面时会自动跳转到登录页面。

noroles.html:如果登陆的用户未分配角色将跳转到该页面。

nopermissions.html:登陆的用户如果访问了没有被授权的资源将跳转到该页面。

admin_index.html:如果登陆的用户角色是admin，进入该页面

user_index.html:如果登陆的用户角色是user，进入该页面

edit.html:编辑页面，只有角色admin可以访问

users_list.html:查看用户列表的页面，只有包含read权限的用户可以访问

四、pom.xml

在pom文件中引入shiro依赖

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>

五、Model实体

User.java

package com.zyy.model;

import lombok.Data;

import java.io.Serializable;
import java.util.List;

/**
 * @ClassName User
 * @Author DoNg
 * @Date 2020/8/12 0012 10:58
 * @Description User
 */
@Data
public class User{
    private String userid;
    private String password;
    private String username;
    private String department;
    private Integer classroom;

    //用户对应的角色集合
    private List<Role> roles;
}

Role.java

package com.zyy.model;

import lombok.Data;

import java.util.List;

/**
 * @ClassName Role
 * @Author DoNg
 * @Date 2020/8/12 0012 17:19
 * @Description Role
 */
@Data
public class Role {
    private String roleid;
    private String roleName;

    //角色对应的权限集合ist
    private List<Permissions> permissions;
}

Permissions.java

package com.zyy.model;

import lombok.Data;

/**
 * @ClassName Permissions
 * @Author DoNg
 * @Date 2020/8/12 0012 17:20
 * @Description Permissions
 */
@Data
public class Permissions {
    private String permid;
    private String permissionsName;
}

六、登录控制器

在登陆的时候，我们需要将用户账号和密码封装成token传入subject.login()中，shiro会帮我们进行登录认证，后面会讲到shiro如何帮我们进行登录认证。

如果我们想根据用户的角色来跳转到不同的页面，那我们只需获取subject，然后用hasRole()即可判断当前用户是否具有某种角色。具体代码如下。

LoginController.java

package com.zyy.controller;

import com.zyy.model.User;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @ClassName LoginController
 * @Author DoNg
 * @Date 2020/8/15 0015 9:49
 * @Description LoginController
 */
@Controller
@RequestMapping("/verify")
public class LoginController {

    @GetMapping("/home")
    public String toHome(){
        //获取身份信息
        Subject currentUser = SecurityUtils.getSubject();
        //根据用户角色的不同进入不同的页面
        if(currentUser.hasRole("admin")){
            return "admin_index";
        } else if (currentUser.hasRole("user")){
            return "user_index";
        }
        return "noroles";
    }

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

    @GetMapping("/noPermissions")
    public String toNoPermissions(){
        return "nopermissions";
    }


    @PostMapping("/login")
    public String toLogin(User user){
        try{
            // 从SecurityUtils里边创建一个 subject
            Subject subject = SecurityUtils.getSubject();
            // 在认证提交前准备 token（令牌）
            UsernamePasswordToken token = new UsernamePasswordToken(user.getUserid(), user.getPassword());
            // 执行认证登陆
            subject.login(token);
            return "redirect:home";
        } catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("账号不存在!!");
        } catch (IncorrectCredentialsException e){
            System.out.println("密码错误!!");
        }
        return "login";
    }
}

七、Shiro 配置类

shirFilter 方法中主要主要配置接口的角色权限，确定接口由哪些角色或者哪些权限的用户可以访问。至于shiro是怎么知道当前用户是否具有某个角色或权限需要用到后面的doGetAuthorizationInfo()方法。

以下为常用Filter

Filter	解释
anon	无参，开放权限，可以理解为匿名用户或游客
authc	无参，需要认证
user	无参，表示必须存在用户，当登入操作时不做检查
perms[user]	参数可写多个，表示需要某个或某些权限才能通过，多个参数时写 perms["user, admin"]，当有多个参数时必须每个参数都通过才算通过
roles[admin]	参数可写多个，表示是某个或某些角色才能通过，多个参数时写 roles["admin，user"]，当有多个参数时必须每个参数都通过才算通过

package com.zyy.config;

import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
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.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.apache.shiro.mgt.SecurityManager;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @ClassName ShiroConfig
 * @Author DoNg
 * @Date 2020/8/13 0013 10:03
 * @Description ShiroConfig
 */
@Configuration
public class ShiroConfig {
    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //拦截器.
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
        //配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了

        //开放登陆接口
        filterChainDefinitionMap.put("/verify/login", "anon");
        //开放用户进入首页的接口
        filterChainDefinitionMap.put("/anon/home", "anon");
        //查看列表,需要权限read
        filterChainDefinitionMap.put("/user/all", "perms[read]");
        //修改用户信息,需要角色admin
        filterChainDefinitionMap.put("/user/edit", "roles[admin]");
        //其余接口一律拦截,主要这行代码必须放在所有权限设置的最后，不然会导致所有 url 都被拦截
        filterChainDefinitionMap.put("/**", "authc");

        //配置过滤规则，从上到下的顺序匹配。
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        //没有登录的用户请求需要登录的页面时自动跳转到登录页面。
        shiroFilterFactoryBean.setLoginUrl("/verify/loginPage");
        //没有权限默认跳转的页面，登录的用户访问了没有被授权的资源自动跳转到的页面。
        shiroFilterFactoryBean.setUnauthorizedUrl("/verify/noPermissions");
        return shiroFilterFactoryBean;
    }

    @Bean
    public Realm myShiroRealm() {
        UserRealm myShiroRealm = new UserRealm();
        return myShiroRealm;
    }


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

    @Bean(name="lifecycleBeanPostProcessor")
    public static LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    /**
     * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     * 配置以下两个bean(DefaultAdvisorAutoProxyCreator(可选)和AuthorizationAttributeSourceAdvisor)即可实现此功能
     *
     * @return
     */
    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }

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

八、自定义 realm 类

需要重写两个方法：

doGetAuthorizationInfo()：用于获取用户的角色和权限信息，这需要我们先自己写好service方法然后在这里调用。shiro在这里拿到角色和权限信息后，上面shirFilter 配置类中的接口拦截配置才会发挥作用。

doGetAuthenticationInfo()：用于登录认证，即判断用户能否登陆成功。还记得之前登陆控制器中传入的token吗，在执行subject.login(token)后会进入该方法。

UserRealm.java

package com.zyy.config;

import com.zyy.model.Permissions;
import com.zyy.model.Role;
import com.zyy.model.User;
import com.zyy.service.UserService;
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 java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * @ClassName UserRealm
 * @Author DoNg
 * @Date 2020/8/13 0013 10:02
 * @Description UserRealm
 */
public class UserRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;

    //shiro的权限信息配置
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //-----------------角色权限认证-----------------
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        String userid = (String) principals.getPrimaryPrincipal();
        List<Role> roles = userService.findRoles(userid);
        Set<String> roleNames = new HashSet<>(roles.size());
        for (Role role : roles) {
            roleNames.add(role.getRoleName());
        }
        //此处把当前subject对应的所有角色信息交给shiro，调用hasRole的时候就根据这些role信息判断
        authorizationInfo.setRoles(roleNames);
        List<Permissions> permissions = userService.findPermissions(userid);
        Set<String> permissionNames = new HashSet<>(permissions.size());
        for (Permissions permission : permissions) {
            permissionNames.add(permission.getPermissionsName());
        }
        //此处把当前subject对应的权限信息交给shiro，当调用hasPermission的时候就会根据这些信息判断
        authorizationInfo.setStringPermissions(permissionNames);
        return authorizationInfo;
    }

    //根据token获取认证信息authenticationInfo
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //------------------身份认证------------------
        String userid = (String)token.getPrincipal();
        User user = userService.findUserById(userid);
        if(user == null){
            return null;
        }
        // 传入用户名和密码进行身份认证，并返回认证信息,调用login的时候会自动比较这里的token和authenticationInfo
        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user.getUserid(), user.getPassword(), getName());
        return authenticationInfo;
    }

}

九、相关逻辑代码

UserService.java

package com.zyy.service;

import com.zyy.model.Permissions;
import com.zyy.model.Role;
import com.zyy.model.User;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @ClassName UserService
 * @Author DoNg
 * @Date 2020/8/12 0012 11:51
 * @Description UserService
 */
public interface UserService {

    //通过id查询用户
    User findUserById(String userid);

    //根据用户id获取用户所有角色
    List<Role> findRoles(String userid);

    //根据用户id获取用户所有权限
    List<Permissions> findPermissions(String userid);

}

UserServiceImpl.java

package com.zyy.service.impl;

import com.zyy.mapper.UserMapper;
import com.zyy.model.Permissions;
import com.zyy.model.Role;
import com.zyy.model.User;
import com.zyy.service.UserService;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thymeleaf.util.StringUtils;

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

/**
 * @ClassName UserServiceImpl
 * @Author DoNg
 * @Date 2020/8/12 0012 11:52
 * @Description UserServiceImpl
 */
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    //通过id查询用户
    @Override
    public User findUserById(String userid) {
        return this.userMapper.selectUserById(userid);
    }

    //根据用户id获取用户所有角色
    @Override
    public List<Role> findRoles(String userid) {
        return this.userMapper.selectRoles(userid);
    }

    //根据用户id获取用户所有权限
    @Override
    public List<Permissions> findPermissions(String userid) {
        //通过用户id获取角色
        List<Role> roles = findRoles(userid);
        //创建list存放角色id
        List<String> rolesid = new ArrayList<>(roles.size());
        for(Role role : roles){
            rolesid.add(role.getRoleid());
        }
        //将存放角色id的list转为','相隔的字符串
        String rolesids = StringUtils.join(rolesid, ",");
        return this.userMapper.selectPermissions(rolesids);
    }

}

UserMapper.java

package com.zyy.mapper;

import com.zyy.model.Permissions;
import com.zyy.model.Role;
import com.zyy.model.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @ClassName UserMapper
 * @Author DoNg
 * @Date 2020/8/12 0012 11:19
 * @Description UserMapper
 */
@Mapper
@Repository
public interface UserMapper {
    //通过id查询用户
    User selectUserById(String userid);
    //根据用户id获取用户所有角色
    List<Role> selectRoles(String userid);
    //根据用户id获取用户所有权限
    List<Permissions> selectPermissions(@Param("rolesids") String rolesids);

}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.zyy.mapper.UserMapper">

    <select id="selectUserById" resultType="com.zyy.model.User">
        select * from user_tb where userid = #{userid}
    </select>

    <select id="selectRoles" parameterType="java.lang.String" resultType="com.zyy.model.Role">
        select * from role_tb where roleid in (select roleid from user_role where userid = #{userid})
    </select>

    <select id="selectPermissions" resultType="com.zyy.model.Permissions">
        select distinct * from permissions_tb where permid in
        (select permid from role_permissions where roleid in
            <foreach collection="rolesids.split(',')" item="item" index="index" open="(" close=")" separator=",">
                #{item}
            </foreach>
        )
    </select>

</mapper>

UserController.java

package com.zyy.controller;


import com.zyy.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;



/**
 * @ClassName UserController
 * @Author DoNg
 * @Date 2020/8/12 0012 11:33
 * @Description UserController
 */
@Controller
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/all")
    public String all(ModelMap model) {
        return "users_list";
    }

    @GetMapping("/edit")
    public String edit(ModelMap model) {
        return "edit";
    }

}

十、用Postman进行测试

测试一：在未登录的情况下直接访问查询页面。结果：跳转到登录页。

测试二：登录第一个用户角色为admin的帐号。结果：登陆成功并跳转到admin对应的页面

测试三：在保证admin登陆成功后继续访问查看所有用户列表的页面。结果：可以访问。

测试四：在保证admin登陆成功后继续访问编辑用户列表的页面。结果：可以访问。

测试五：登录第二个用户角色为user的帐号。结果：登陆成功并跳转到user对应的页面

测试六：在保证user登陆成功后继续访问查看所有用户列表的页面。结果：可以访问。

测试七：在保证user登陆成功后继续访问编辑用户列表的页面。结果：不可以访问，跳转到提示页面。

测试八：登录第三个没有分配角色的用户。结果：转到提示页面

测试九：输入错误的密码或不存在的帐号。