狂神说--SpringBoot整合Shiro

最新推荐文章于 2022-11-11 00:05:32 发布

小小酒馆的掌柜

最新推荐文章于 2022-11-11 00:05:32 发布

阅读量694

点赞数 3

文章标签： spring boot shiro

本文链接：https://blog.csdn.net/weixin_45535873/article/details/118882777

版权

1、shiro简介

1.1、什么是Shiro？

Apache Shiro 是一个Java 的安全（权限）框架。
Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环
境。
Shiro可以完成，认证，授权，加密，会话管理，Web集成，缓存等。
下载地址：http://shiro.apac he.org/

1.2、有哪些功能？

在这里插入图片描述

Authentication：身份认证、登录，验证用户是不是拥有相应的身份；
Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限，即判断用户能否进行什么操作，如：验证某个用户是否拥有某个角色，或者细粒度的验证某个用户对某个资源是否具有某个权限！
Session Manager：会话管理，即用户登录后就是第一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通的JavaSE环境，也可以是Web环境；
Cryptography：加密，保护数据的安全性，如密码加密存储到数据库中，而不是明文存储；
Web Support：Web支持，可以非常容易的集成到Web环境；
Caching：缓存，比如用户登录后，其用户信息，拥有的角色、权限不必每次去查，这样可以提高效率
Concurrency：Shiro支持多线程应用的并发验证，即，如在一个线程中开启另一个线程，能把权限自动的传播过去
Testing：提供测试支持；
Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了

1.3、Shiro架构（外部）

从外部来看Shiro，即从应用程序角度来观察如何使用shiro完成工作：

在这里插入图片描述

subject：应用代码直接交互的对象是Subject，也就是说Shiro的对外API核心就是Subject，Subject代表了当前的用户，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等，与Subject的所有交互都会委托给SecurityManager；Subject其实是一个门面，SecurityManageer 才是实际的执行者
SecurityManager：安全管理器，即所有与安全有关的操作都会SercurityManager交互，并且它管理着所有的Subject，可以看出它是Shiro的核心，它负责与Shiro的其他组件进行交互，它相当于SpringMVC的DispatcherServlet的角色
Realm：Shiro从Realm获取安全数据（如用户，角色，权限），就是说SecurityManager 要验证用户身份，那么它需要从Realm 获取相应的用户进行比较，来确定用户的身份是否合法；也需要从Realm得到用户相应的角色、权限，进行验证用户的操作是否能够进行，可以把Realm看成

1.4、Shiro架构（内部）

在这里插入图片描述

2、SpringBoot集成

准备工作

搭建一个SpringBoot项目、选中web模块即可！

导入Maven依赖thymeleaf

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

编写一个页面 index.html

<!DOCTYPE html>
<html lang="en"xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>首页</h1>
<p th:text="${msg}"></p>
</body>
</html>

写controller进行访问测试

package com.kuang.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class MyController {
    @RequestMapping({"/","/index"})
    public String toIndex(Model model){
        model.addAttribute("msg","hello,Shiro");
        return "index";
    }
}

整合Shiro

回顾核心API：

Subject：用户主体
SecurityManager：安全管理器
Realm：Shiro 连接数据

步骤：

1. 导入Shiro 和 spring整合的依赖

<!--shiro整合spring-->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.7.1</version>
</dependency>

2. 编写Shiro 配置类 config包

package com.kuang.config;
import org.springframework.context.annotation.Configuration;
//声明为配置类
@Configuration
public class ShiroConfig {
    //创建 ShiroFilterFactoryBean
    
    //创建 DefaultWebSecurityManager
    
    //创建 realm 对象
    
}

3.我们倒着来，先想办法创建一个 realm 对象

4. 我们需要自定义一个 realm 类，用来编写一些查询的方法，或者认证与授权的逻辑

package com.kuang.config;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
//自定义Realm
public class UserRealm extends AuthorizingRealm {
	//执行授权逻辑
    @Override
    protected AuthorizationInfo
    doGetAuthorizationInfo(PrincipalCollection principals) {
        System.out.println("执行了=>授权逻辑PrincipalCollection");
        return null;
    }
	//执行认证逻辑
    @Override
    protected AuthenticationInfo
    doGetAuthenticationInfo(AuthenticationToken token) throws
    AuthenticationException {
        System.out.println("执行了=>认证逻辑AuthenticationToken");
        return null;
    }
}

5.将这个类注册到我们的Bean中！ ShiroConfig

@Configuration
public class ShiroConfig {
    //创建 ShiroFilterFactoryBean
    
    //创建 DefaultWebSecurityManager
    
    //创建 realm 对象
    @Bean
    public UserRealm userRealm(){
    return new UserRealm();
    }
}

6.接下来我们该去创建 DefaultWebSecurityManager 了

//创建 DefaultWebSecurityManager
@Bean(name = "securityManager")
public DefaultWebSecurityManager
    getDefaultWebSecurityManager(@Qualifier("userRealm")UserRealm userRealm){
    DefaultWebSecurityManager securityManager = new
    DefaultWebSecurityManager();
    //关联Realm
    securityManager.setRealm(userRealm);
    return securityManager;
}

7.接下来我们该去创建 ShiroFilterFactoryBean 了

//创建 ShiroFilterFactoryBean
@Bean
public ShiroFilterFactoryBean
getShiroFilterFactoryBean(@Qualifier("securityManager")DefaultWebSecurityManager securityManager){
    ShiroFilterFactoryBean shiroFilterFactoryBean = new
    ShiroFilterFactoryBean();
    //设置安全管理器
    shiroFilterFactoryBean.setSecurityManager(securityManager);
    return shiroFilterFactoryBean;
}

以上完整配置

package com.kuang.config;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//声明为配置类
@Configuration
public class ShiroConfig {
	//创建 ShiroFilterFactoryBean
    @Bean
    public ShiroFilterFactoryBean  getShiroFilterFactoryBean(@Qualifier("securityManager")DefaultWebSecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new
        ShiroFilterFactoryBean();
        //设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        return shiroFilterFactoryBean;
    }
    
    //创建 DefaultWebSecurityManager
    @Bean(name = "securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm")UserRealm userRealm){
        DefaultWebSecurityManager securityManager = new
        DefaultWebSecurityManager();
        //关联Realm
        securityManager.setRealm(userRealm);
        return securityManager;
    }
    
    //创建 realm 对象
    @Bean
    public UserRealm userRealm(){
        return new UserRealm();
    }
}

页面拦截实现

编写两个页面、在templates目录下新建一个 user 目录 add.html update.html

在这里插入图片描述

编写跳转到页面的controller

@RequestMapping("/user/add")
public String toAdd(){
	return "user/add";
}
@RequestMapping("/user/update")
public String toUpdate(){
    return "user/update";
}

在index页面上，增加跳转链接

<a th:href="@{/user/add}">add</a> | <a
th:href="@{/user/update}">update</a>

准备添加Shiro的内置过滤器

@Bean
public ShiroFilterFactoryBean
getShiroFilterFactoryBean(@Qualifier("securityManager")DefaultWebSecurit
yManager securityManager){
    ShiroFilterFactoryBean shiroFilterFactoryBean = new
    ShiroFilterFactoryBean();
    //设置安全管理器
    shiroFilterFactoryBean.setSecurityManager(securityManager);
    /*
    添加Shiro内置过滤器，常用的有如下过滤器：
    anon： 无需认证就可以访问
    authc： 必须认证才可以访问
    user： 如果使用了记住我功能就可以直接访问
    perms: 拥有某个资源权限才可以访问
    role： 拥有某个角色权限才可以访问
    */
    Map<String,String> filterMap = new LinkedHashMap<String, String>();
    filterMap.put("/user/add","authc");
    filterMap.put("/user/update","authc");
    shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);
    return shiroFilterFactoryBean;
}

再起启动测试，访问链接进行测试！拦截OK！但是发现，点击后会跳转到一个Login.jsp页面，这个不是我们想要的效果，我们需要自己定义一个Login页面！

我们编写一个自己的Login页面

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>登录页面</title>
</head>
<body>
<h1>登录页面</h1>
    <hr>
    <form action="">
    <p>
    用户名： <input type="text" name="username">
    </p>
    <p>
    密码： <input type="text" name="password">
    </p>
    <p>
    <input type="submit">
    </p>
    </form>
</body>
</html>

编写跳转的controller

@RequestMapping("/toLogin")
public String toLogin(){
	return "login";
}

在shiro中配置一下！ ShiroFilterFactoryBean() 方法下面

//修改到要跳转的login页面；
shiroFilterFactoryBean.setLoginUrl("/toLogin");

再次测试，成功的跳转到了我们指定的Login页面！

优化一下代码，我们这里的拦截可以使用通配符来操作

Map<String,String> filterMap = new LinkedHashMap<String, String>();
//filterMap.put("/user/add","authc");
//filterMap.put("/user/update","authc");
filterMap.put("/user/*","authc");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);

登录认证操作

编写一个登录的controller

@RequestMapping("/login")
public String login(String username,String password,Model model){
    //使用shiro，编写认证操作
    //1. 获取Subject
    Subject subject = SecurityUtils.getSubject();
    //2. 封装用户的数据
    UsernamePasswordToken token = new UsernamePasswordToken(username,
    password);
    //3. 执行登录的方法，只要没有异常就代表登录成功！
    try {
    	subject.login(token); //登录成功！返回首页
    return "index";
    } catch (UnknownAccountException e) { //用户名不存在
    	model.addAttribute("msg","用户名不存在");
    return "login";
    } catch (IncorrectCredentialsException e) { //密码错误
    	model.addAttribute("msg","密码错误");
    return "login";
    }
}

在前端修改对应的信息输出或者请求！

登录页面增加一个 msg 提示：

<p style="color:red;" th:text="${msg}"></p>

给表单增加一个提交地址：

<form th:action="@{/login}">
    <p>用户名： <input type="text" name="username"></p>
    <p>密码： <input type="text" name="password"></p>
    <p> <input type="submit"> </p>
</form>

理论，假设我们提交了表单，他会经过我们刚才编写的UserRealm，我们提交测试一下

在这里插入图片描述

在 UserRealm 中编写用户认证的判断逻辑

//执行认证逻辑
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    System.out.println("执行了=>认证逻辑AuthenticationToken");
    //假设数据库的用户名和密码
    String name = "root";
    String password = "123456";
    //1.判断用户名
    UsernamePasswordToken userToken = (UsernamePasswordToken)token;
    if (!userToken.getUsername().equals(name)){
    	//用户名不存在
    	return null; //shiro底层就会抛出 UnknownAccountException
     }
    //2. 验证密码,我们可以使用一个AuthenticationInfo实现类SimpleAuthenticationInfo
    // shiro会自动帮我们验证！重点是第二个参数就是要验证的密码！
    return new SimpleAuthenticationInfo("", password, "");
}

测试一下！成功实现登录的认证操作！

整合数据库

导入Mybatis相关依赖

<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--mybatis整合springboot-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>
<!--druid数据源-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>
<!--log4j-->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

编写配置文件-连接配置 application.yml

# 端口号
server:
  port: 8888

# 数据库连接信息
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/homework?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 配置Druid数据源
    type: com.alibaba.druid.pool.DruidDataSource

    #SpringBoot默认是不注入这些的，需要自己绑定
    #druid数据源专有配置
    initialSize: 5 # 初始化连接池大小
    minIdle: 5 # 最小值
    maxActive: 20 # 最大值
    maxWait: 60000  # 最长连接等待时间
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000 # 连接保持空闲而不被驱逐的最长时间
    validationQuery: SELECT 1 FROM DUAL #用来检测连接是否有效的sql
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true

    #配置监控统计拦截的filters，stat：监控统计、log4j：日志记录、wall：防御sql注入
    #如果允许报错，java.lang.ClassNotFoundException: org.apache.Log4j.Property
    #则导入log4j 依赖就行
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500


# mybatis配置
mybatis:
  type-aliases-package: com.zhang.pojo  # 实体类所在的包路径
  mapper-locations: classpath*:mapper/*.xml     # mybatis的映射文件所在的包路径

编写实体类

package com.kuang.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
}

编写Mapper接口

@Repository
@Mapper
public interface UserMapper {
	User queryUserByName(String name);
}

编写Mapper配置文件

<?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.kuang.mapper.UserMapper">
    <select id="queryUserByName" parameterType="String"
    resultType="User">
    select * from user where name = #{name}
    </select>
</mapper>

编写UserService 层

public interface UserService {
	User queryUserByName(String name);
}

package com.kuang.service;
import com.kuang.mapper.UserMapper;
import com.kuang.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    UserMapper userMapper;
    @Override
    public User queryUserByName(String name) {
    	return userMapper.queryUserByName(name);
    }
}

改造UserRealm，连接到数据库进行真实的操作！

//自定义Realm
public class UserRealm extends AuthorizingRealm {
    @Autowired
    UserService userService;
    //执行授权逻辑
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
   	 	System.out.println("执行了=>授权逻辑PrincipalCollection");
    	return null;
    }
    //执行认证逻辑
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    	System.out.println("执行了=>认证逻辑AuthenticationToken");
    	UsernamePasswordToken userToken = (UsernamePasswordToken)token;
    	//真实连接数据库
    	User user =
    	userService.queryUserByName(userToken.getUsername());
    	if (user==null){
    	//用户名不存在
    		return null; //shiro底层就会抛出 UnknownAccountException
    	}
    	return new SimpleAuthenticationInfo("", user.getPwd(), "");
    }
}

用户授权操作

使用shiro的过滤器来拦截请求即可！

在 ShiroFilterFactoryBean 中添加一个过滤器

//授权过滤器
filterMap.put("/user/add","perms[add]"); //进入add页面需要有add的权限！

我们再次启动测试一下，访问add，发现以下错误！未授权错误！

在这里插入图片描述

注意：当我们实现权限拦截后，shiro会自动跳转到未授权的页面，但我们没有这个页面，所有401 了

配置一个未授权的提示的页面，增加一个controller提示

@RequestMapping("/noauth")
@ResponseBody
public String noAuth(){
	return "未经授权不能访问此页面";
}

然后再 shiroFilterFactoryBean 中配置一个未授权的请求页面！

shiroFilterFactoryBean.setUnauthorizedUrl("/noauth")

测试，现在没有授权，可以跳转到我们指定的位置了！

Shiro授权

在UserRealm 中添加授权的逻辑，增加授权的字符串！

//执行授权逻辑
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
    System.out.println("执行了=>授权逻辑PrincipalCollection");
    //给资源进行授权
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    //添加资源的授权字符串
    info.addStringPermission("user:add");
    return info;
}

我们再次登录测试，发现登录的用户是可以进行访问add 页面了！授权成功！

问题：我们现在完全是硬编码，无论是谁登录上来，都可以实现授权通过，但是真实的业务情况应该是，每个用户拥有自己的一些权限，从而进行操作，所以说，权限，应该在用户的数据库中，正常的情况下，应该数据库中是由一个权限表的，我们需要联表查询，但是这里为了大家操作理解方便一些，我们直接在数据库表中增加一个字段来进行操作！

在这里插入图片描述

修改实体类，增加一个字段

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
    private String perms;
}

我们现在需要再自定义的授权认证中，获取登录的用户，从而实现动态认证授权操作！

在用户登录认证的时候，将用户放在 Principal 中，改造下之前的代码

然后再授权的地方获得这个用户，从而获得它的权限

//执行授权逻辑
@Override
protected AuthorizationInfo
doGetAuthorizationInfo(PrincipalCollection principals) {
    System.out.println("执行了=>授权逻辑PrincipalCollection");
    //给资源进行授权
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    //添加资源的授权字符串
    //info.addStringPermission("user:add");
    Subject subject = SecurityUtils.getSubject(); //获得当前对象
    User currentUser = (User) subject.getPrincipal(); //拿到User对象
    info.addStringPermission(currentUser.getPerms()); //设置权限
    return info;
}

我们给数据库中的用户增加一些权限

在过滤器中，将 update 请求也进行权限拦截

//授权过滤器
filterMap.put("/user/add","perms[add]");
filterMap.put("/user/update","perms[update]");

测试完美通过OK！

整合Thymeleaf

根据权限展示不同的前端页面

添加Maven的依赖；

<dependency>
<groupId>com.github.theborakompanioni</groupId>
<artifactId>thymeleaf-extras-shiro</artifactId>
<version>2.0.0</version>
</dependency>

配置一个shiro的Dialect ，在shiro的配置中增加一个Bean

//配置ShiroDialect：方言，用于 thymeleaf 和 shiro 标签配合使用
@Bean
public ShiroDialect getShiroDialect(){
	return new ShiroDialect();
}

修改前端的配置

<div shiro:hasPermission="add">
<a th:href="@{/user/add}">add</a>
</div>
<div shiro:hasPermission="update">
<a th:href="@{/user/update}">update</a>
</div>

我们在去测试一下，可以发现，现在首页什么都没有了，因为我们没有登录，我们可以尝试登录下，来判断这个Shiro的效果！登录后，可以看到不同的用户，有不同的效果，现在就已经接近完美了~！还不是最完美

为了完美，我们在用户登录后应该把信息放到Session中，我们完善下！在执行认证逻辑时候，加入session

在controller的login方法中

subject.login(token);//执行登录方法，如果没有错误就OK了
//登陆成功存放用户信息
Subject currentSubject = SecurityUtils.getSubject();
Session session = currentSubject.getSession();
session.setAttribute("loginUser",username);

6.前端从session中获取，然后用来判断是否显示登录,加入注销按钮

<p th:if="${session.loginUser}==null">
<a th:href="@{/toLogin}">登录</a>
</p>
<p th:if="${session.loginUser}==null">
<a th:href="@{/logOut}">注销</a>
</p>

7.controller层中加入注销方法

//注销登录功能
@RequestMapping("/logOut")
public String logOut(){

    Subject currentUser = SecurityUtils.getSubject();
    currentUser.logout();

    return "index";
}