Shiro在springboot中使用

shiro和jwt还有springsecurity的区别，这个你们区分的出来吗

jwt是用来存储用户信息的，shiro和springsecurity是用来认证授权的

---

shiro的核心实现是—过滤器（拦截或过虑请求），用于用户访问页面（URL）时进行权限控制。

shiro的主要功能模块有：

Authentication：身份认证/登录，验证用户是不是拥有相应的身份；

Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；

Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

Web Support：Web支持，可以非常容易的集成到Web环境；

Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；

Concurrency：shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；

Testing：提供测试支持；

Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

记住一点，Shiro不会去维护用户、维护权限；这些需要我们自己去设计/提供；然后通过相应的接口注入给Shiro即可。

shiro的三大组件

• Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，

保存用户信息，负责认证和授权方法调用，只要调了方法就会到SecurityManager

• SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；它管理着所有Subject；可以看出它是Shiro的核心，负责认证和授权的管理

• Realm：域，连接数据库获取认证和授权信息的桥梁，Shiro从Realm获取安全数据（如用户、角色、权限）；

也就是说对于我们而言，最简单的一个Shiro应用：
1、应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；
2、我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。
从以上也可以看出，Shiro不提供维护用户/权限，而是通过Realm让开发人员自己注入

开发的步骤应该是这样的：

1.pom依赖
2.重写realm域，定义一个类继承AuthorizingRealm，重写授权、认证的方法
3.添加shiro的配置，将自己的realm域注入，且交给安全管理器使用，配置过滤条件（拦截哪些路径，放行哪些路径）
4.在拦截器里面使用，subject.login(token)跑去realm中认证方法，subject.hasRole（）或者check的一些方法 跑去realm中的授权方法。

第一步.pom.xml

shiro-spring

<?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.troy</groupId>
    <artifactId>springshiro</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>1.5.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>1.5.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>1.5.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-Java</artifactId>
            <version>5.1.9</version>
        </dependency>
		
        <!--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>
	
	
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.4</version>
        </dependency>
    </dependencies>

</project>

第二步.yml

没有shiro的配置

server:
  port: 8082
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spring_shiro?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
  http:
    encoding:
      charset: utf-8
      enabled: true

配置shiro

(1)验证，以及权限的添加MyShiroRealm.class

//实现AuthorizingRealm接口用户用户认证
public class MyShiroRealm extends AuthorizingRealm{

    //用于用户查询
    @Autowired
    private ILoginService loginService;

    //角色权限和对应权限添加
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获取登录用户名
        String name= (String) principalCollection.getPrimaryPrincipal();
        //查询用户名称
        User user = loginService.findByName(name);
        //添加角色和权限
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for (Role role:user.getRoles()) {
            //添加角色
            simpleAuthorizationInfo.addRole(role.getRoleName());
            for (Permission permission:role.getPermissions()) {
                //添加权限
                simpleAuthorizationInfo.addStringPermission(permission.getPermission());
            }
        }
        return simpleAuthorizationInfo;
    }

    //用户认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //加这一步的目的是在Post请求的时候会先进认证，然后在到请求
        if (authenticationToken.getPrincipal() == null) {
            return null;
        }
        //获取用户信息
        String name = authenticationToken.getPrincipal().toString();
        User user = loginService.findByName(name);
        if (user == null) {
            //这里返回后会报出对应异常
            return null;
        } else {
            //这里验证authenticationToken和simpleAuthenticationInfo的信息
			
			/**
         * Shiro底层获取SimpleAuthenticationInfo的参数，例如获取password判断和用户输入的密码是否一致
         *    1）如果密码不一致，抛出IncorrectCredentialsException异常
         *    2）如果密码一致， 把principal存入session域
          */ 
		  
			 /**
         * 参数一： principal  登录用户对象，用于Subject.getPrincipal()方法获取
         * 参数二： password   数据库中用户的密码
         * 参数三： realm的别名， 在多个Realm的情况下使用，用于区分用户表的。只有一张用户表不需要别名
         */
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(name, user.getPassword().toString(), getName());
            return simpleAuthenticationInfo;
        }
    }
}

(2)过滤配置：ShiroConfiguration.class

一：与认证（登录）相关的过滤器的使用
过滤器：(先拦截，在判断)
anon：匿名过滤器，代表不认证（登录）也可以访问该请求，通过对静态资源进行放行（指css，js，图片都没有了）
authc：认证过滤器，代表必须认证成功才可以访问该资源，如果认证不成功或没有认证，会自动跳转到login.jsp页面（自带的），但是可以修改默认登录页面，用
用法：
/make/=anon
/ = authc
anon一定要放在authc前,/** = authc表示拦截所有的请求，而在其上面的/make/**=anon表示这个放行不拦截
该拦截的资源用authc，该放行的资源用anon
又由于静态资源也会被拦截，所以anon主要用来给静态资源放行（css，js，图片等）
/login.do因为是登录请求，必须使用anon过滤器放行！！！否则无法登录啦！

二与授权相关的过滤器

注意要收到导入这两个包
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;

@Configuration
public class ShiroConfiguration {

    //将自己的验证方式加入容器
    @Bean
    public MyShiroRealm myShiroRealm() {
        MyShiroRealm myShiroRealm = new MyShiroRealm();
		// myShiroRealm.setCredentialsMatcher(new CustomCredentialsMatcher()); // 添加凭证器

        return myShiroRealm;
    }

    //权限管理，配置主要是Realm的管理认证
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

    //Filter工厂，设置对应的过滤条件和跳转条件
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String,String> map = new HashMap<String, String>();
        //登出
        map.put("/logout","logout");
        //对所有用户认证
        map.put("/**","authc");
		// 对/user/login放行，不拦截直接进入控制器，通过调用方法去认证授权
        map.put("/user/login", "anon");
        //过期跳转登录，登录
        shiroFilterFactoryBean.setLoginUrl("/login");
        //首页，authc拦截成功跳转首页
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //错误页面，认证不通过跳转
        shiroFilterFactoryBean.setUnauthorizedUrl("/error");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

    //加入注解的使用，不加入这个注解不生效
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
}

控制器调用方法使用

package com.zykj.controller;

import com.mysql.cj.Session;
import com.zykj.common.MyEventPublisher;
import com.zykj.pojo.UserVo;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.security.Permission;
import java.security.Security;

/**
 * @author lc
 * @version 1.0
 * @date 2021/10/22 14:50
 */
@RestController
@RequestMapping("/user")
public class LoginController {

    @Autowired
    private com.zykj.common.MyEventPublisher myEventPublisher;

    @GetMapping("/login")
    public String login(@RequestParam("id") String id ,
                       @RequestParam("password") String password) {
        // shiro登录认证的逻辑
        // 1.获取Subject对象
        Subject subject = SecurityUtils.getSubject();
        // 2.封装认证信息（用户名和密码）
        UsernamePasswordToken token = new UsernamePasswordToken(id, password);
        // 3.调用subject.login（）方法,认证
        subject.login(token);
        // 4.授权,判断是否有该权限
        subject.hasRole("role1");

        System.out.println("=====认证成功=====");

        return "认证成功";
    }



}

Shiro登录认证的流程是怎样的？

LoginController 的login方法调用Subject.login()，从而就到SecurityManagerAuthRealm的认证方法，编写判断用户名和返回数据库密码的逻辑，从数据库获得数据

Shiro登录授权的流程是怎样的？

LoginController的login方法调用 subject.hasRole(“role1”）或者check的一些方法，从而就到SecurityManagerAuthRealm的授权方法，在判断添不添加权限

传递-加密的用户信息

上面是直接传递用户的信息，这是不安全的，可以加密-加盐加密（推荐使用）

什么是加盐加密

加密流程: 使用md5算法加密1次 + 盐（变量，每个用户不同的）= 2次使用md5加密

我们设置这个项目的盐就是每个用户自己的邮箱

加盐加密实现

1）编写代码对密码加盐加密，—只是让我们看看是如何加盐加密
实际就是new Md5Hash（原密码，盐）直接new出来加盐加密后的密码，在.String转换成字符串

import org.apache.shiro.crypto.hash.Md5Hash;

/**
 * 加盐加密的工具
 */
public class Demo {

    public static void main(String[] args) {
        //1.原密码
        String password = "123";

        //2.盐
        String salt = "lw@export.com";

        //3.加盐加密
        /**
         * 参数一：原密码
         * 参数二：盐
         * 参数三（可选）：加密次数，默认1次
         */
        Md5Hash md5Hash = new Md5Hash(password,salt);

        System.out.println(md5Hash.toString());
    }

}

以下才是真正的代码
2）编写自定义凭证匹配器
凭证匹配器:
替我们实现密码比较，他会在调用自定义realm的身份认证方法后来执行！

退出登录也用shiro

@RequestMapping("/logout")
    public String logout(){
        //删除session的登录数
        session.removeAttribute("loginUser");
        session.removeAttribute("menus");

        //Shiro登录注销（底层：删除之前Shiro存入的session的key）
        //防止浏览器记住登录认证
        Subject subject = SecurityUtils.getSubject();
        subject.logout();

        return "redirect:/login.jsp";
    }