SaaS-HRM（8）Shiro在SpringBoot中的应用和Shiro中的会话管理

最新推荐文章于 2022-04-07 22:42:42 发布

zdwhong

最新推荐文章于 2022-04-07 22:42:42 发布

阅读量201

点赞数

分类专栏： SaaS-HRM软件即服务—人力资源管理 Shiro 文章标签： shiro springboot seeesion

本文链接：https://blog.csdn.net/zengdongwen/article/details/103366535

版权

SaaS-HRM软件即服务—人力资源管理同时被 2 个专栏收录

10 篇文章 7 订阅

订阅专栏

Shiro

2 篇文章 0 订阅

订阅专栏

上一篇讲解了Shiro的入门案例，基于ini方式，对Shiro有了一个初步的认识。本次讲解的是Shiro在SpringBoot工程中的应用。

1、Shiro在SpringBoot工程中的应用

Apache Shiro是一个功能强大、灵活的，开源的安全框架。它可以干净利落地处理身份验证、授权、企业会话管理和加密。越来越多的企业使用Shiro作为项目的安全框架，保证项目的平稳运行。
在之前的讲解中只是单独的使用shiro，方便大家对shiro有一个直观且清晰的认知，今天就来看一下shiro在springBoot工程中如何使用以及其他特性。

1.1 创建数据库表

Shiro其实也是基于RBAC模型来做权限管理的，所以本次案例也就需要用到RBAC相关的五张表，表结构关系如下：

创建数据库以及相关表结构的sql语句如下：

--创建数据库
CREATE DATABASE shiro_springboot;


SET FOREIGN_KEY_CHECKS=0;

DROP TABLE IF EXISTS `pe_permission`;
CREATE TABLE `pe_permission` (
  `id` varchar(40) NOT NULL COMMENT '主键',
  `name` varchar(255) DEFAULT NULL COMMENT '权限名称',
  `code` varchar(20) DEFAULT NULL,
  `description` text COMMENT '权限描述',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO `pe_permission` VALUES ('1', '添加用户', 'user-add', null);
INSERT INTO `pe_permission` VALUES ('2', '查询用户', 'user-find', null);
INSERT INTO `pe_permission` VALUES ('3', '更新用户', 'user-update', null);
INSERT INTO `pe_permission` VALUES ('4', '删除用户', 'user-delete', null);

DROP TABLE IF EXISTS `pe_role`;
CREATE TABLE `pe_role` (
  `id` varchar(40) NOT NULL COMMENT '主键ID',
  `name` varchar(40) DEFAULT NULL COMMENT '权限名称',
  `description` varchar(255) DEFAULT NULL COMMENT '说明',
  PRIMARY KEY (`id`),
  UNIQUE KEY `UK_k3beff7qglfn58qsf2yvbg41i` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO `pe_role` VALUES ('1', '系统管理员', '系统日常维护');
INSERT INTO `pe_role` VALUES ('2', '普通员工', '普通操作权限');

DROP TABLE IF EXISTS `pe_role_permission`;
CREATE TABLE `pe_role_permission` (
  `role_id` varchar(40) NOT NULL COMMENT '角色ID',
  `permission_id` varchar(40) NOT NULL COMMENT '权限ID',
  PRIMARY KEY (`role_id`,`permission_id`),
  KEY `FK74qx7rkbtq2wqms78gljv87a0` (`permission_id`),
  KEY `FKee9dk0vg99shvsytflym6egxd` (`role_id`),
  CONSTRAINT `fk-p-rid` FOREIGN KEY (`role_id`) REFERENCES `pe_role` (`id`),
  CONSTRAINT `fk-pid` FOREIGN KEY (`permission_id`) REFERENCES `pe_permission` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO `pe_role_permission` VALUES ('1', '1');
INSERT INTO `pe_role_permission` VALUES ('1', '2');
INSERT INTO `pe_role_permission` VALUES ('2', '2');
INSERT INTO `pe_role_permission` VALUES ('1', '3');
INSERT INTO `pe_role_permission` VALUES ('1', '4');

DROP TABLE IF EXISTS `pe_user`;
CREATE TABLE `pe_user` (
  `id` varchar(40) NOT NULL COMMENT 'ID',
  `username` varchar(255) NOT NULL COMMENT '用户名称',
  `password` varchar(255) DEFAULT NULL COMMENT '密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
--注意：这里的password都是经过shiro提供的Md5Hash进行了加密，加密的盐是username（用户名），加密次数是3，具体参考后面写的UserController中的login方法
INSERT INTO `pe_user` VALUES ('1', 'zhangsan', 'b51ae3e5279bc66eae7a4fe2600ab0b1');
INSERT INTO `pe_user` VALUES ('2', 'lisi', '16f807d62105b4896034552ee5caeb8a');
INSERT INTO `pe_user` VALUES ('3', 'wangwu', 'afdda7acc3098eef7177baca693430e5');


DROP TABLE IF EXISTS `pe_user_role`;
CREATE TABLE `pe_user_role` (
  `role_id` varchar(40) NOT NULL COMMENT '角色ID',
  `user_id` varchar(40) NOT NULL COMMENT '权限ID',
  KEY `FK74qx7rkbtq2wqms78gljv87a1` (`role_id`),
  KEY `FKee9dk0vg99shvsytflym6egx1` (`user_id`),
  CONSTRAINT `fk-rid` FOREIGN KEY (`role_id`) REFERENCES `pe_role` (`id`),
  CONSTRAINT `fk-uid` FOREIGN KEY (`user_id`) REFERENCES `pe_user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO `pe_user_role` VALUES ('1', '1');

1.2 创建maven工程shiro_springboot

IDEA中创建一个工程shiro_springboot；

1.2.1 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zdw.shiro</groupId>
    <artifactId>shiro_springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <fastjson.version>1.2.47</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-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.16</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
    <build>
        <plugins>
            <!--编译插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <!--单元测试插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.12.4</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.2.2 创建实体类

在工程下面创建com.zdw.shiro.domain包，里面创建实体类：

User：用户相关实体类

package com.zdw.shiro.domain;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "pe_user")
@Getter
@Setter
public class User implements Serializable {

    private static final long serialVersionUID = -168256759999485870L;
    @Id
    private String id;
    private String username;
    private String password;

    /**
     *  JsonIgnore
     *     : 忽略json转化
     */
    @JsonIgnore
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name="pe_user_role",joinColumns={@JoinColumn(name="user_id",referencedColumnName="id")},
            inverseJoinColumns={@JoinColumn(name="role_id",referencedColumnName="id")}
    )
    private Set<Role> roles = new HashSet<Role>();//用户与角色   多对多
}

Role：角色相关实体类

package com.zdw.shiro.domain;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "pe_role")
@Getter
@Setter
public class Role implements Serializable {

    private static final long serialVersionUID = 9031519702648309677L;
    @Id
    private String id;
    private String name;
    private String description;

    //角色与用户   多对多
    /**
     *  JsonIgnore
     *     : 忽略json转化，不加这个注解的话，User和Role互相调用的话，转json的时候会报错
     */
    @JsonIgnore
    @ManyToMany(mappedBy="roles")
    private Set<User> users = new HashSet<User>(0);

    /**
     *  JsonIgnore
     *     : 忽略json转化，不加这个注解的话，Permission和Role互相调用的话，转json的时候会报错
     */
    @JsonIgnore
    //角色与权限  多对多
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name="pe_role_permission",
            joinColumns={@JoinColumn(name="role_id",referencedColumnName="id")},
            inverseJoinColumns={@JoinColumn(name="permission_id",referencedColumnName="id")})
    private Set<Permission> permissions = new HashSet<Permission>(0);
}

Permission：权限相关实体类

package com.zdw.shiro.domain;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;

@Entity
@Table(name = "pe_permission")
@Getter
@Setter
public class Permission implements Serializable {
    private static final long serialVersionUID = 2838414976847571891L;
    @Id
    private String id;
    private String name;
    private String code;
    private String description;
}

1.2.3 创建持久层DAO

package com.zdw.shiro.dao;

import com.zdw.shiro.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface UserDao extends JpaRepository<User,String>,JpaSpecificationExecutor<User> {
    //根据用户名查询用户信息
    public User findByUsername(String username);
}

1.2.4 创建业务层Service

package com.zdw.shiro.service;

import com.zdw.shiro.dao.UserDao;
import com.zdw.shiro.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public User findByUser(String username){
        return userDao.findByUsername(username);
    }

    public List<User> findAll(){
        return userDao.findAll();
    }
}

1.2.5 创建控制器Controller

package com.zdw.shiro.controller;

import com.zdw.shiro.domain.User;
import com.zdw.shiro.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    //添加
    @RequestMapping(value = "/user",method = RequestMethod.POST)
    public String add() {
        return "添加用户成功";
    }

    //查询
    @RequestMapping(value = "/user",method = RequestMethod.GET)
    public List<User> find() {
        //return "查询用户成功";
        return userService.findAll();
    }

    //更新
    @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    public String update(String id) {
        return "更新用户成功";
    }

    //删除
    @RequestMapping(value = "/user/{id}",method = RequestMethod.DELETE)
    public String delete() {
        return "删除用户成功";
    }

    @RequestMapping(value = "/user/home",method = RequestMethod.GET)
    public String home(String id) {
        return "访问首页成功";
    }
}

1.2.6 创建启动类

package com.zdw.shiro;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Bean;
import org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter;

@SpringBootApplication(scanBasePackages = "com.zdw.shiro")
@EntityScan("com.zdw.shiro.domain")
public class ShiroApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShiroApplication.class,args);
    }
    //解决JPA的no session问题
    @Bean
    public OpenEntityManagerInViewFilter openEntityManagerInViewFilter() {
        return new OpenEntityManagerInViewFilter();
    }
}

1.2.7 创建配置文件application.yml

server:
  port: 9000
spring:
  application:
    name: shiro_springboot #指定服务名
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shiro_springboot?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    database: MySQL
    show-sql: true
    open-in-view: true
  redis:
    host: 127.0.0.1
    port: 6379

启动工程，访问：http://localhost:9000/user，可以看到浏览器上已经展示了用户信息，说明工程搭建成功。

1.3 整合Shiro

1.3.1 添加shiro相关的依赖

        <!--shiro和spring整合-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!--shiro核心包-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!--shiro与redis整合-->
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>3.0.0</version>
        </dependency>

1.3.2 添加登录方法

认证：身份认证/登录，验证用户是不是拥有相应的身份。基于shiro的认证，shiro需要采集到用户登录数据使用subject的login方法进入realm完成认证工作。

在UserController中添加登录的方法：login

   /**
     *  1.传统登录
     *      前端发送登录请求 => 接口部分获取用户名密码 => 程序员在接口部分手动控制
     *  2.shiro登录
     *      前端发送登录请求 => 接口部分获取用户名密码 => 通过subject.login =>  realm域的认证方法
     */
    //用户登录
    @RequestMapping(value="/login")
    public String login(String username,String password) {
        try {
            //从环境中获取Subject
            Subject subject = SecurityUtils.getSubject();
            //构造登录数据
            /**
             * 密码加密：
             *     shiro提供的md5加密
             *     Md5Hash:
             *      参数一：加密的内容
             *              111111   --- abcd
             *      参数二：盐（加密的混淆字符串）（用户登录的用户名）
             *              111111+混淆字符串
             *      参数三：加密次数
             */
            password = new Md5Hash(password,username,3).toString();
            UsernamePasswordToken upToken = new UsernamePasswordToken(username,password);
            //调用login方法，请求Realm的认证方法
            subject.login(upToken);
            return "登录成功";
        }catch (Exception e){
            e.printStackTrace();
            return "用户名或密码错误";
        }
    }

1.3.3 自定义Realm

Realm域：Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。

package com.zdw.shiro.realm;

import com.zdw.shiro.domain.Permission;
import com.zdw.shiro.domain.Role;
import com.zdw.shiro.domain.User;
import com.zdw.shiro.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 org.springframework.stereotype.Component;

import java.util.HashSet;
import java.util.Set;

/**
 * 自定义Realm
 */
public class CustomRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    public void setName(String name){
        super.setName("customRealm");
    }

    /**
     * 授权方法
     *      操作的时候，判断用户是否具有响应的权限
     *          先认证 -- 安全数据
     *          再授权 -- 根据安全数据获取用户具有的所有操作权限
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //得到唯一的安全数据
        User user = (User) principalCollection.getPrimaryPrincipal();
        //得到用户对应的权限和角色信息
        Set<String> roles = new HashSet<>();//角色信息
        Set<String> perms = new HashSet<>();//权限信息
        for (Role role : user.getRoles()) {
            roles.add(role.getName());
            for (Permission perm : role.getPermissions()) {
                perms.add(perm.getCode());
            }
        }
        //构造返回数据
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.setStringPermissions(perms);
        info.setRoles(roles);
        return info;
    }

    //认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //获取登录的用户名和密码
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) authenticationToken;
        String username = usernamePasswordToken.getUsername();
        String password = new String(usernamePasswordToken.getPassword());
        //根据用户名查询用户信息
        User user = userService.findByUsername(username);
        //判断登录的密码和查询得到的用户密码是否相等
        if(user!=null && password.equals(user.getPassword())){
            //返回安全数据，第一个参数是安全数据，第二个参数是密码，第三个是Realm名称
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,password,this.getName());
            return info;
        }
        //密码不对，返回null
        return null;
    }
}

1.3.4 shiro中的过滤器

过滤器简称	对应的java类	解释
anon	org.apache.shiro.web.filter.authc.AnonymousFilter	无参，开放权限，可以理解为匿名用户或游客
authc	org.apache.shiro.web.filter.authc.FormAuthenticationFilter	无参，需要认证
authcBasic	org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter	无参，表示 httpBasic 认证
perms	org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter	参数可写多个，表示需要某个或某些权限才能通过，多个参数时写 perms[“user, admin”]，当有多个参数时必须每个参数都通过才算通过
port	org.apache.shiro.web.filter.authz.PortFilter	当请求的URL端口不是8081时，跳转到当前访问主机HOST的8081端口
rest	org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter	根据请求的方法，相当于 perms[user:method]，其中 method 为 post，get，delete 等
roles	org.apache.shiro.web.filter.authz.RolesAuthorizationFilter	参数可写多个，表示是某个或某些角色才能通过，多个参数时写 roles[“admin，user”]，当有多个参数时必须每个参数都通过才算通过
ssl	org.apache.shiro.web.filter.authz.SslFilter	无参，表示安全的URL请求，协议为 https
user	org.apache.shiro.web.filter.authc.UserFilter	无参，表示必须存在用户，当登入操作时不做检查
logout	org.apache.shiro.web.filter.authc.LogoutFilter	无参，注销，执行后会直接跳转到 shiroFilterFactoryBean.setLoginUrl(); 设置的 url

注意：

anon, authc, authcBasic, user 是第一组认证过滤器，

perms, port, rest, roles, ssl 是第二组授权过滤器，

要通过授权过滤器，就先要完成登录认证操作（即先要完成认证才能前去寻找授权) 才能走第二组授权器（例如访问需要 roles 权限的 url，如果还没有登录的话，会直接跳转到shiroFilterFactoryBean.setLoginUrl(); 设置的 url ）

1.3.4 Shiro的配置

SecurityManager 是 Shiro 架构的心脏，用于协调内部的多个组件完成全部认证授权的过程。例如通过调用realm完成认证与登录。使用基于springboot的配置方式完成SecurityManager，Realm的装配。

创建配置类：ShiroConfiguration，里面进行Shiro相关的配置，具体如下：

package com.zdw.shiro;

import com.zdw.shiro.realm.CustomRealm;
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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class ShiroConfiguration {

    //1 配置自定义的Realm
    @Bean
    public CustomRealm customRealm(){
        return new CustomRealm();
    }

    //2 配置安全管理器
    @Bean
    public SecurityManager securityManager(CustomRealm customRealm){
        //使用默认的安全管理器
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //将自定义的realm交给安全管理器统一调度管理
        securityManager.setRealm(customRealm);
        return securityManager;
    }

    //3.配置shiro的过滤器工厂
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager){
        //1.创建shiro过滤器工厂
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //2 设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //3.通用配置（配置登录页面，登录成功页面，验证未成功页面）
        shiroFilterFactoryBean.setLoginUrl("/loginError?code=1");//设置登录页面，这里设置跳转到UserController的loginError方法
        shiroFilterFactoryBean.setUnauthorizedUrl("/loginError?code=2");//设置授权失败跳转的页面
        /**
         * 4 设置所有的过滤器：有顺序map
         *     key = 拦截的url地址，支持通配符的形式
         *     value = 过滤器类型
         *          shiro常用过滤器
         *              anno  ：匿名访问（表明此链接所有人可以访问）
         *              authc  ：认证后访问（表明此链接需登录认证成功之后可以访问）
         */
        Map<String,String> filterMap = new LinkedHashMap<>();//有序的map
        filterMap.put("/user/home","anon");//当前请求地址可以匿名访问
        filterMap.put("/user/**","authc");//当前请求地址需要认证通过才可访问
        //5 设置过滤器
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);
        return shiroFilterFactoryBean;
    }

    //4 配置shiro注解支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }
}

1.3.5 启动工程，测试认证

1. postman测试/user/home请求地址（请求的是UserController的home方法），配置的是匿名访问，所以不登录应该也可以访问的：

1.2 postman测试/user(post方式），测试的UserController的add方法，此路径配置了必须要登录成功才能访问的，

首先在没登录的情况下直接请求；

然后调用登录方法进行登录操作：登录用的数据zhangsan等都是来自之前创建的数据表pe_user；

登录成功之后，再次请求add方法，可以发现请求成功的：

1.3.6 测试（配置）授权

在ShiroConfiguration配置类的方法：shiroFilterFactoryBean，添加权限的配置，先配置角色：

//使用过滤器的形式配置请求地址的依赖权限
filterMap.put("/user/**","roles[系统管理员]");//必要要有系统管理员的角色，不具备，跳转到setUnauthorizedUrl地址
filterMap.put("/user/{id}","perms[user-update]");//必要有用户修改的权限，不具备，跳转到setUnauthorizedUrl地址

然后我们熟悉下表数据：

postman测试：首先以lisi进行登录：localhost:9000/login?username=lisi&password=123456

登录成功之后，然后访问：localhost:9000/user/

我们再以张三登录：localhost:9000/login?username=zhangsan&password=123456

然后访问：localhost:9000/user/

1.3.7 测试（注解）授权

上面做的是通过Filter里面添加配置来对某个路径进行权限控制，我们在CustomRealm中配置开启了shiro的注解支持，因此我们也可以在对应的方法上面添加shiro的注解来进行权限控制，先注释掉CustomRealm的权限控制代码：

 //使用过滤器的形式配置请求地址的依赖权限
//filterMap.put("/user/**","roles[系统管理员]");//必要要有系统管理员的角色，不具备，跳转到setUnauthorizedUrl地址
//filterMap.put("/user/{id}","perms[user-update]");//必要有用户修改的权限，不具备，跳转到setUnauthorizedUrl地址

然后在UserController的update方法中，添加如下的注解：

@RequiresPermissions(value = "user-update")
//@RequiresRoles(value = "系统管理员")
@RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
public String update(String id) {
    return "更新用户成功";
}

postman测试：

以lisi登录：localhost:9000/login?username=lisi&password=123456，

登录成功，然后访问添加用户的方法：localhost:9000/user/1111111

奇怪啊，怎么出异常了啊，可以查看系统后台的控制台也打印出了异常信息：

org.apache.shiro.authz.AuthorizationException: Not authorized to invoke method: public java.lang.String com.zdw.shiro.controller.UserController.update(java.lang.String)

这其实是注解授权和配置授权的区别，我们在配置授权的时候，有这样的注释：

不具备，跳转到setUnauthorizedUrl地址

也就是说，如果授权失败，那么就会跳转到我们配置的如下的地址：

shiroFilterFactoryBean.setUnauthorizedUrl("/loginError?code=2");//设置授权失败跳转的页面

但是如果是注解授权的话，则是会抛出异常的，那么为了不抛这个异常，我们就添加一个全局异常处理，对未授权的异常进行处理，然后返回友好的错误信。添加BaseExceptionHandler如下：

package com.zdw.shiro;

import org.apache.shiro.authz.AuthorizationException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 自定义的公共异常处理器
 *      1.声明异常处理器
 *      2.对异常统一处理
 */
@ControllerAdvice
public class BaseExceptionHandler {
    @ExceptionHandler(value = AuthorizationException.class)//捕获未授权的异常
    @ResponseBody
    public String error(HttpServletRequest request, HttpServletResponse response, AuthorizationException e) {
        return "注解权限控制返回信息：您未授权访问该地址";
    }
}

重新启动，然后再次以lisi登录，然后访问：localhost:9000/user/1111111

如果我们以张三登录，那么访问这个地址是可以成功的，自行测试。

2、Shiro中的会话管理

在shiro里所有的用户的会话信息都会由Shiro来进行控制，shiro提供的会话可以用于JavaSE/JavaEE环境，不依赖于任何底层容器，可以独立使用，是完整的会话模块。通过Shiro的会话管理器（SessionManager）进行统一的会话管理。

2.1 什么是shiro的会话管理

SessionManager（会话管理器）：管理所有Subject的session包括创建、维护、删除、失效、验证等工作。
SessionManager是顶层组件，由SecurityManager（安全管理器）管理。
shiro提供了三个默认实现：
1. DefaultSessionManager ：用于JavaSE环境
2. ServletContainerSessionManager：用于Web环境，直接使用servlet容器的会话。
3. DefaultWebSessionManager ：用于web环境，自己维护会话（自己维护着会话，直接废弃了Servlet容器的会话管理）。

在web程序中，通过shiro的Subject.login()方法登录成功后，用户的认证信息实际上是保存在HttpSession中的，通过如下代码验证。

    //登录成功后，调用该方法可以：打印所有session内容
    @RequestMapping(value="/show")
    public String show(HttpSession httpSession){
        //获取httpSession中所有的键值
        Enumeration<String> attributeNames = httpSession.getAttributeNames();
        //遍历取到所有的值
        while(attributeNames.hasMoreElements()){
            //得到键值
            String name = attributeNames.nextElement().toString();
            //得到value值
            Object value = httpSession.getAttribute(name);
            System.out.println("<B>" + name + "</B>=" + value + "<br>/n");
        }
        return "读取HttpSession成功";
    }

运行应用，先访问登录接口进行登录成功，然后访问：http://localhost:9000/show，可以看到控制台打印：

<B>org.apache.shiro.subject.support.DefaultSubjectContext_AUTHENTICATED_SESSION_KEY</B>=true<br>/n
<B>org.apache.shiro.web.session.HttpServletSession.HOST_SESSION_KEY</B>=0:0:0:0:0:0:0:1<br>/n
<B>org.apache.shiro.subject.support.DefaultSubjectContext_PRINCIPALS_SESSION_KEY</B>=com.zdw.shiro.domain.User@6f442126<br>/n

从 com.zdw.shiro.domain.User@6f442126 可以看出我们的安全数据User是存储到了HttpSession当中了。

2.2 应用场景分析

在分布式系统或者微服务架构下，都是通过统一的认证中心进行用户认证。如果使用默认会话管理，用户信息只会保存到一台服务器上。那么其他服务就需要进行会话的同步。

如果我们自己去实现Shiro的会话管理器的话，我们可以把数据存储到Redis当中。

会话管理器可以指定sessionId的生成以及获取方式。
通过sessionDao完成模拟session存入，取出等操作。

2.3 Shiro结合redis的统一会话管理

2.3.1 步骤分析

安全管理器负责管理SessionManager（会话管理器），而会话管理器不能直接操作redis，所以会话管理器需要通过SessionDao的实现来维护会话，操作Redis。

2.3.2 构建环境

引入依赖：

        <!--shiro与redis整合-->
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>3.0.0</version>
        </dependency>

application.yml中添加Redis配置：

  redis:
    host: 127.0.0.1
    port: 6379

这些操作我们在创建工程的时候已经进行了导入和书写。

2.3.3 自定义shiro会话管理器

package com.zdw.shiro.session;

import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.util.StringUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.Serializable;

/**
 * 自定义的会话管理器，
 * 需要继承org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
 */
public class CustomSessionManager extends DefaultWebSessionManager {
    /**
     * 前后端约定把SessionId放到头信息中，
     *      请求头名称：Authorization： sessionid
     *      所以我们在该方法中也是从请求头中获取sessionId
     */
    @Override
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        //把request转成HttpServletRequest
        HttpServletRequest servletRequest = WebUtils.toHttp(request);
        //获取请求头 Authorization,得到的值就是SessionId
        String sessionId = servletRequest.getHeader("Authorization");
        if(StringUtils.isEmpty(sessionId)){//如果为空，那么调用父类DefaultWebSessionManager的方法生成SessionId，并返回给客户端
            Serializable sid = super.getSessionId(request, response);
            return sid;
        }else{
            //返回sessionId；
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");//表示从header中去
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, sessionId);//表示sessionId的值是什么
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);//表示是否需要校验
            return sessionId;
        }
    }
}

2.3.4 配置Shiro基于redis的会话管理

在Shiro配置类：ShiroConfiguration添加基于redis的会话管理配置

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;

    //配置shiro的RedisManager，通过shiro-redis包提供的RedisManager统一对redis操作
    public RedisManager redisManager(){
        RedisManager redisManager = new RedisManager();
        redisManager.setHost(host);
        redisManager.setPort(port);
        return redisManager;
    }

    //Shiro内部有自己的本地缓存机制，为了更加统一方便管理，全部替换redis实现
    public RedisCacheManager redisCacheManager(){
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }

    //配置SessionDao，使用shiro-redis实现的基于redis的sessionDao
    /**
     * RedisSessionDAO shiro sessionDao层的实现 通过redis
     * 使用的是shiro-redis开源插件
     */
    public RedisSessionDAO redisSessionDAO(){
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }

    //配置会话管理器，指定sessionDao的依赖关系
    public DefaultWebSessionManager defaultWebSessionManager(){
        CustomSessionManager customSessionManager = new CustomSessionManager();
        customSessionManager.setSessionDAO(redisSessionDAO());
        return customSessionManager;
    }

修改Shiro配置类：ShiroConfiguration中的配置安全管理器的方法：securityManager，告诉安全管理器我们现在要使用自定义的会话管理器和缓存管理器

    //2 配置安全管理器
    @Bean
    public SecurityManager securityManager(CustomRealm customRealm){
        //使用默认的安全管理器
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        //设置自定义的会话管理器
        securityManager.setSessionManager(defaultWebSessionManager());
        //设置自定义的缓存管理器
        securityManager.setCacheManager(redisCacheManager());

        //将自定义的realm交给安全管理器统一调度管理
        securityManager.setRealm(customRealm);
        return securityManager;
    }

修改User实体类，如果要使用redis存储安全数据，那么安全数据需要实现一个接口：AuthCachePrincipal，它是redis和shiro插件包提供的接口，里面有一个方法：getAuthCacheKey，在方法中我们可以自定义redis中key的生成规则，如果返回空，就会用它默认的实现。如果不实现该接口，会报异常：

Principal must implement org.crazycake.shiro.AuthCachePrincipal.\nshiro-redis will get the key for store authorization object in Redis from org.crazycake.shiro.AuthCachePrincipal

package com.zdw.shiro.domain;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.crazycake.shiro.AuthCachePrincipal;

import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "pe_user")
@Getter
@Setter
public class User implements Serializable,AuthCachePrincipal {

    private static final long serialVersionUID = -168256759999485870L;
    @Id
    private String id;
    private String username;
    private String password;

    /**
     *  JsonIgnore
     *     : 忽略json转化
     */
    @JsonIgnore
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name="pe_user_role",joinColumns={@JoinColumn(name="user_id",referencedColumnName="id")},
            inverseJoinColumns={@JoinColumn(name="role_id",referencedColumnName="id")}
    )
    private Set<Role> roles = new HashSet<Role>();//用户与角色   多对多

    @Override
    public String getAuthCacheKey() {
        return null;
    }
}

2.3.5 测试

1 我们首先需要启动redis，如果没有安装，请先自行安装redis。启动之后，使用redis的客户端连接工具连接上redis服务：

2、为了使测试更加直观，修改UserController的login方法，添加如下代码，获取到sessionId并打印：

           //通过Subject获取Session对象
            Session session = subject.getSession();
            //得到sessionId
            String sessionId = (String)session.getId();

            //调用login方法，请求Realm的认证方法
            subject.login(upToken);
            return "登录成功，sessionId："+sessionId;

3、因为postman里面是共享session的，所以为了效果：使用浏览器和postman一起测试，这样保证是在不同的地方登录。

启动工程，先在浏览器上面进行登录，访问：http://localhost:9000/login?username=lisi&password=123456

然后通过redis的客户端工具也可以看到redis里面已经存储了该sessionId：

再用postman进行需要登录才能访问的路径，注意一定要加上header：Authorization，值就是刚才的sessionId；

可以看到，在postman当中我们不需要登录，就能直接访问需要登录成功才能访问的url（只是因为sessionId当中没有权限信息），因此我们的shiro整合redis的会话管理是成功的。

zdwhong

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SaaS-HRM（8）Shiro在SpringBoot中的应用和Shiro中的会话管理

上一篇讲解了Shiro的入门案例，基于ini方式，对Shiro有了一个初步的认识。本次讲解的是Shiro在SpringBoot工程中的应用。1、Shiro在SpringBoot工程中的应用 Apache Shiro是一个功能强大、灵活的，开源的安全框架。它可以干净利落地处理身份验证、授权、企业会话管理和加密。越来越多的企业使用Shiro作为项目的安全框架，保证项目的平稳运行。...
复制链接

扫一扫