Shiro

1.权限的管理

1.1 什么是权限管理

基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。
权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。

1.2 什么是身份认证

身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件Key等刷卡系统，则需要刷卡。

1.3 什么是授权

授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的。

2.什么是shiro

Apache Shiro™ is a powerful and easy-to-use Java security framework that performs authentication, authorization, cryptography, and session management. With Shiro’s easy-to-understand API, you can quickly and easily secure any application – from the smallest mobile applications to the largest web and enterprise applications. Shiro 是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理。使用Shiro易于理解的API，您可以快速轻松地保护任何应用程序—从最小的移动应用程序到最大的web和企业应用程序。

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理、缓存管理等功能，组成了一个通用的安全认证框架。

3.shiro的核心架构

3.1 Subject

Subject即主体，外部应用与subject进行交互，subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。<br />    Subject在shiro中是一个接口，接口中定义了很多认证授权相关的方法，外部程序通过subject进行认证授权，而subject是通过SecurityManager安全管理器进行认证授权。

3.2 SecurityManager

SecurityManager即安全管理器，对全部的subject进行安全管理，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，实质上SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。
SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口。

3.3 Authenticator

Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供ModularRealmAuthenticator实现类，通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。

3.4 Authorizer

Authorizer即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。

3.5 Realm

Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据，比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。

• 注意：不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。

  3.6 SessionManager

  sessionManager即会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。

  3.7 SessionDAO

  SessionDAO即会话dao，是对session会话操作的一套接口，比如要将session存储到数据库，可以通过jdbc将会话存储到数据库。

  3.8 CacheManager

  CacheManager即缓存管理，将用户权限数据存储在缓存，这样可以提高性能。

  3.9 Cryptography

  Cryptography即密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。

4. shiro中的认证

4.1 认证

身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。

4.2 shiro中认证的关键对象

• Subject：主体

访问系统的用户，主体可以是用户、程序等，进行认证的都称为主体；

• Principal：身份信息

是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）。

• credential：凭证信息

是只有主体自己知道的安全信息，如密码、证书等。

4.3 认证流程

应用程序通过subject带上token去找securityManager进行认证，securityManager去realm中获取数据，跟token中带过来的数据进行校验，如果认证成功进入系统，如果认证失败抛出异常。

4.4认证的开发

1. 创建项目并引入依赖

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-core</artifactId>
  <version>1.5.3</version>
</dependency>

2. 引入shiro配置文件并加入如下配置

shiro配置文件后缀只能是.ini，可在resources目录中创建配置文件shiro.ini。1

[users]
xiaochen=123
zhangsan=456

3.开发认证代码

public class TestAuthenticator {
    public static void main(String[] args) {
        //创建securityManager
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
        //设置安全管理器验证时的数据来源
        defaultSecurityManager.setRealm(new IniRealm("classpath:shiro.ini"));
        //为安全验证工具类中设置默认安全管理器
        SecurityUtils.setSecurityManager(defaultSecurityManager);
        //获取主体对象
        Subject subject = SecurityUtils.getSubject();
        //创建token令牌
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen1", "123");
        try {
            subject.login(token);//用户登录
            System.out.println("登录成功~~");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误!!");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误!!!");
        }
    }
}

• DisabledAccountException（帐号被禁用）
• LockedAccountException（帐号被锁定）
• ExcessiveAttemptsException（登录失败次数过多）
• ExpiredCredentialsException（凭证过期）等

4.5 自定义Realm

上边的程序使用的是Shiro自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义realm。

1.shiro提供的Realm

2.根据认证源码认证使用的是SimpleAccountRealm

SimpleAccountRealm的部分源码中有两个方法一个是认证，一个是授权。

public class SimpleAccountRealm extends AuthorizingRealm {
        //.......省略
        //认证
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        SimpleAccount account = getUser(upToken.getUsername());
        if (account != null) {
            if (account.isLocked()) {
                throw new LockedAccountException("Account [" + account + "] is locked.");
            }
            if (account.isCredentialsExpired()) {
                String msg = "The credentials for account [" + account + "] are expired";
                throw new ExpiredCredentialsException(msg);
            }

        }

        return account;
    }
        //授权
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = getUsername(principals);
        USERS_LOCK.readLock().lock();
        try {
            return this.users.get(username);
        } finally {
            USERS_LOCK.readLock().unlock();
        }
    }
}

3.自定义realm

/**
 * 自定义realm
 */
public class CustomerRealm extends AuthorizingRealm {
    //授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    //认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String principal = (String) token.getPrincipal();
        if("xiaochen".equals(principal)){
            return new SimpleAuthenticationInfo(principal,"123",this.getName());
        }
        return null;
    }
}

4.使用自定义Realm认证

public class TestAuthenticatorCusttomerRealm {
    public static void main(String[] args) {
        //创建securityManager
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
        //IniRealm realm = new IniRealm("classpath:shiro.ini");
        //设置安全管理器的数据来源->realm
        defaultSecurityManager.setRealm(new CustomerRealm());
        //将安全工具类中设置默认安全管理器
        SecurityUtils.setSecurityManager(defaultSecurityManager);
        //获取主体对象
        Subject subject = SecurityUtils.getSubject();
        //创建token令牌
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");
        try {
            subject.login(token);//用户登录
            System.out.println("登录成功~~");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误!!");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误!!!");
        }
    }
}

4.6 使用MD5和Salt

什么是MD5？ MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。 特点： 1、MD5算法不可逆，只能从明文生成密文 2、当加密内容相同时，无论使用MD5进行多少次加密，生成结果始终一致 作用：加密、签名。 实际应用是将盐（salt）和散列后的值存在数据库中，自动realm从数据库取出盐和加密后的值由shiro完成密码校验。 如果直接对密码进行散列，那么黑客（统称那些有能力窃取用户数据并企图得到用户密码的人）可以对一个已知密码进行散列，然后通过对比散列值得到某用户的密码。换句话说，虽然黑客不能取得某特定用户的密码，但他可以知道使用特定密码的用户有哪些。 加Salt可以一定程度上解决这一问题。所谓加Salt，就是加点“佐料”。其基本想法是这样的——当用户首次提供密码时（通常是注册时），由系统自动往这个密码里撒一些“佐料”，然后再散列。而当用户登录时，系统为用户提供的代码撒上同样的“佐料”，然后散列，再比较散列值，已确定密码是否正确。 这里的“佐料”被称作“Salt值”，这个值是由系统随机生成的，并且只有系统知道。这样，即便两个用户使用了同一个密码，由于系统为它们生成的salt值不同，他们的散列值也是不同的。即便黑客可以通过自己的密码和自己生成的散列值来找具有特定密码的用户，但这个几率太小了（密码和salt值都得和黑客使用的一样才行）。 需要强调的是，验证密码时要使用和最初散列密码时使用“相同的”佐料，所以Salt值是要存放在数据库里的，因此实际开发中的存放用户的数据库表一般会有存放salt值的字段。 案例： 随机盐生成工具类：

public class SaltUtils {
    public static String getSalt(int count){//使用参数决定生成的随机盐长度
        char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()".toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < count; i++) {
            char aChar = chars[new Random().nextInt(chars.length)];
            sb.append(aChar);
        }
        return sb.toString();
    }
}

    @Test
    public void testMD5(){
        //创建MD5加密对象，需要注意的是，MD5加密必须使用构造方法传参
//        Md5Hash md5Hash = new Md5Hash();
//        md5Hash.setBytes("12345".getBytes());//set方法传参不会做MD5加密
        //参数1：被加密的对象
        //参数2：随机盐
        //参数3：hash散列次数，一般取1024或2048
        Md5Hash md5Hash = new Md5Hash("111");
        System.out.println(md5Hash.toHex());//698d51a19d8a121ce581499d7b701668
        md5Hash=new Md5Hash("111","qazxsw");
        System.out.println(md5Hash.toHex());//24fbf59e4d9cc107f6cd64838ef63f98
        md5Hash=new Md5Hash("111","qazxsw",1024);
        System.out.println(md5Hash.toHex());//bb6df0fc3cc8e8c1f5e75975faeb81d9
    }

1.自定义md5+salt的realm

/**
 * 自定义md5+salt realm
 */
public class CustomerRealm extends AuthorizingRealm {
    //授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    //认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String principal = (String) token.getPrincipal();
        if("xiaochen".equals(principal)){
            String password = "24fbf59e4d9cc107f6cd64838ef63f98";
            String salt = "qazxsw";
            return new SimpleAuthenticationInfo(principal,
                                                password,                                 
                                                ByteSource.Util.bytes(salt),
                                                this.getName());
        }
        return null;
    }

2.使用md5 + salt 认证

public class TestAuthenticatorCusttomerRealm {
    public static void main(String[] args) {
        //创建securityManager
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
        //IniRealm realm = new IniRealm("classpath:shiro.ini");
        //设置为自定义realm获取认证数据
        CustomerRealm customerRealm = new CustomerRealm();
        //设置md5加密
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        credentialsMatcher.setHashAlgorithmName("MD5");
        credentialsMatcher.setHashIterations(1024);//设置散列次数
        customerRealm.setCredentialsMatcher(credentialsMatcher);
        //设置安全管理器的数据来源
        defaultSecurityManager.setRealm(customerRealm);
        //将安全工具类中设置默认安全管理器
        SecurityUtils.setSecurityManager(defaultSecurityManager);
        //获取主体对象
        Subject subject = SecurityUtils.getSubject();
        //创建token令牌
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");
        try {
            subject.login(token);//用户登录
            System.out.println("登录成功~~");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误!!");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误!!!");
        }
    }
}

5. shiro中的授权

5.1 授权

授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的。

5.2 关键对象

授权可简单理解为who对what(which)进行How操作：
Who，即主体（Subject），主体需要访问系统中的资源。
What，即资源（Resource)，如系统菜单、页面、按钮、类方法、系统商品信息等。资源包括资源类型和资源实例，比如商品信息为资源类型，类型为t01的商品为资源实例，编号为001的商品信息也属于资源实例。
How，权限/许可（Permission)，规定了主体对资源的操作许可，权限离开资源没有意义，如用户查询权限、用户添加权限、某个类方法的调用权限、编号为001用户的修改权限等，通过权限可知主体对哪些资源都有哪些操作许可。

5.3 授权流程5.4 授权方式（RBAC）

• 基于角色的访问控制

  • RBAC基于角色的访问控制（Role-Based Access Control）是以角色为中心进行访问控制

    if(subject.hasRole("admin")){
    //操作什么资源
    }
    

• 基于资源的访问控制

  • RBAC基于资源的访问控制（Resource-Based Access Control）是以资源为中心进行访问控制

    if(subject.isPermission("user:update:01")){ //资源实例
    //对01用户进行修改
    }
    if(subject.isPermission("user:update:*")){  //资源类型
    //对所有用户进行修改
    }
    

    5.5 权限字符串

    权限字符串的规则是：资源标识符：操作：资源实例标识符，意思是对哪个资源的哪个实例具有什么操作，“:”是资源/操作/实例的分割符，权限字符串也可以使用通配符。资源实例标识符如果使用通配符时，此部分设置可省略不写。如下例中的user:create:*等效于user:create。
    例子：

• 用户创建权限：user:create，或user:create:*

• 用户修改实例001的权限：user:update:001
• 用户实例001的所有权限：user:*:001

• 同时具备用户实例001，002，003，004的操作权限：user:*:001,002,003,004

  5.6 shiro中授权编程实现方式

• 编程式

  Subject subject = SecurityUtils.getSubject();
  if(subject.hasRole(“admin”)) {
    //有权限
  } else {
    //无权限
  }
  

• 注解式

  @RequiresRoles("admin")
  public void hello() {
    //有权限
  }
  

• 标签式

  JSP/GSP 标签：在JSP/GSP 页面通过相应的标签完成：
  <shiro:hasRole name="admin">
    <!— 有权限—>
  </shiro:hasRole>
  注意: Thymeleaf 中使用shiro需要额外集成!
  

  5.7 开发授权

  1.realm的实现

  ```java public class CustomerRealm extends AuthorizingRealm { //授权方法 @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

    String primaryPrincipal = (String) principals.getPrimaryPrincipal();
    System.out.println("primaryPrincipal = " + primaryPrincipal);
  
    SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
  
    simpleAuthorizationInfo.addRole("admin");
  
    simpleAuthorizationInfo.addStringPermission("user:update:*");
    simpleAuthorizationInfo.addStringPermission("product:*:*");
  

    return simpleAuthorizationInfo;
}

//认证方法
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    String principal = (String) token.getPrincipal();
    if("xiaochen".equals(principal)){
        String password = "3c88b338102c1a343bcb88cd3878758e";
        String salt = "Q4F%";
        return new SimpleAuthenticationInfo(principal,password, 
                                            ByteSource.Util.bytes(salt),this.getName());
    }
    return null;
}

}

<a name="070c3c6b"></a>
##### 2.授权
```java
public class TestAuthenticatorCusttomerRealm {
    public static void main(String[] args) {
        //创建securityManager
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
        //IniRealm realm = new IniRealm("classpath:shiro.ini");
        //设置为自定义realm获取认证数据
        CustomerRealm customerRealm = new CustomerRealm();
        //设置md5加密
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        credentialsMatcher.setHashAlgorithmName("MD5");
        credentialsMatcher.setHashIterations(1024);//设置散列次数
        customerRealm.setCredentialsMatcher(credentialsMatcher);
        defaultSecurityManager.setRealm(customerRealm);
        //将安装工具类中设置默认安全管理器
        SecurityUtils.setSecurityManager(defaultSecurityManager);
        //获取主体对象
        Subject subject = SecurityUtils.getSubject();
        //创建token令牌
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");
        try {
            subject.login(token);//用户登录
            System.out.println("登录成功~~");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误!!");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误!!!");
        }
        //认证通过
        if(subject.isAuthenticated()){
            //基于角色权限管理
            boolean admin = subject.hasRole("admin");
            System.out.println(admin);

            boolean permitted = subject.isPermitted("product:create:001");
            System.out.println(permitted);
        }

    }
}

6.整合SpringBoot项目实战

web项目中资源分类：
1、无须登录就可以见的资源
2、登录过后可见的资源
3、登录过后需要拥有某种权限的资源

6.0 整合思路 6.1创建springboot项目

# 1 依赖：创建时选择devTools、lombok、web即可
    由于项目中使用了jsp，而不是默认的thymeleaf模板，因此需要引入以下两个依赖
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

# 2 配置
    server:
          port: 8888
          servlet:
            context-path: /shiro
    spring:
          mvc:
            view:
              suffix: .jsp
              prefix: /
          application:
            name: shiro
# 3 在main下创建webapp目录，在目录下创建index.jsp（受限资源）和login.jsp（公共资源）

# 4 启动项目，测试访问
    http://localhost:8888/shiro/index.jsp
    能正常访问，代表项目创建成功。
    注意：
        创建的是单体项目，可正常访问，如果创建的是moudle，在启动时，必须在idea中进行配置，否则会出现找不到jsp的错误。
        edit configrations-->environment-->working directory-->$MODULE_WORKING_DIR$

6.2 引入shiro依赖

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-spring-boot-starter</artifactId>
  <version>1.5.3</version>
</dependency>

6.3 配置shiro环境

# 1.创建配置类：config/ShiroConfig.java

/**
 * 用于配置shiro环境
 * 根据整合思路图可知，在此应该至少配置三个类：shiroFilter、sercurityManager、realm
 * shiroFilter:拦截所有用户请求
 * sercurityManager:进行认证和授权
 * realm:提供认证和授权需要的数据
 */
@Configuration
public class ShiroConfig {

    //1、shiroFilter:
    //该对象拦截请求后需要调用sercurityManager进行认证和授权，需要注入sercurityManager
    //通过参数注入
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        return shiroFilterFactoryBean;
    }
    //2、sercurityManager：
    //该对象在进行认证和授权时需要的数据必须由realm提供，需要注入realm
    //通过参数注入
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }
    //3、realm:
    //该对象用于获取认证和授权需要的数据，一般从数据库获取
    @Bean
    public Realm realm(){
        return new CustomerRealm();
    }
}

# 2.自定义realm

public class CustomerRealm extends AuthorizingRealm {
    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }
    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        return null;
    }
}

# 3 启动项目测试
    项目能够成功启动，则可进行下一步--使用shiro进行权限控制

# 4 测试shiro权限认证
    修改ShiroConfig.java，对shiroFilter进行修改。

public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);

        //配置受限资源，对shiro来说，当一个资源不被显示配置为受限资源，默认都是公共资源
        //通过shiroFilterFactoryBean.setFilterChainDefinitionMap(Map<String, String> filterChainDefinitionMap)进行配置
        //map中的key用于设置资源路径，value用于设置对key的访问请求采用哪种过滤规则
        Map<String,String> map=new HashMap();
        map.put("/index.jsp","authc");//authc：过滤器，表示访问当前资源需要进行认证和授权
        //实际应用中，一般会将应用中所有资源都设置为需要认证和授权，然后再将不需要认证和授权的资源进行单独设置，进行放行。如下例所示：
        //map.put("/**","authc");           //拦截所有请求
        //map.put("/user/login","anon");    //放行登录操作请求
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        //当shiroFilter在拦截请求时，发现请求的资源为受限资源，而当前请求的用户不能通过认证或者没有相应的权限，则会默认将请求重定向到login.jsp。
        //可通过shiroFilterFactoryBean.setLoginUrl(String loginUrl)修改默认的重定向资源。

        return shiroFilterFactoryBean;
    }

6.4 常见过滤器

• 注意: shiro提供了多个默认的过滤器，我们可以用这些过滤器来配置控制指定url的权限： | 配置缩写 | 对应的过滤器 | 功能 | | —- | —- | —- | | anon | AnonymousFilter | 指定url可以匿名访问 | | authc | FormAuthenticationFilter | 指定url需要form表单登录，默认会从请求中获取username
  、password
  ,rememberMe
  等参数并尝试登录，如果登录不了就会跳转到loginUrl配置的路径。我们也可以用这个过滤器做默认的登录逻辑，但是一般都是我们自己在控制器写登录逻辑的，自己写的话出错返回的信息都可以定制嘛。 | | authcBasic | BasicHttpAuthenticationFilter | 指定url需要basic登录 | | logout | LogoutFilter | 登出过滤器，配置指定url就可以实现退出功能，非常方便 | | noSessionCreation | NoSessionCreationFilter | 禁止创建会话 | | perms | PermissionsAuthorizationFilter | 需要指定权限才能访问 | | port | PortFilter | 需要指定端口才能访问 | | rest | HttpMethodPermissionFilter | 将http请求方法转化成相应的动词来构造一个权限字符串，这个感觉意义不大，有兴趣自己看源码的注释 | | roles | RolesAuthorizationFilter | 需要指定角色才能访问 | | ssl | SslFilter | 需要https请求才能访问 | | user | UserFilter | 需要已登录或“记住我”的用户才能访问 |

自定义过滤器

    在实际开发中，如果当前业务使用shiro提供的过滤器无法实现需求时，可以通过自定义过滤器来解决相应问题。
    继承**AccessControlFilter**即可进行过滤器自定义，该类提供了访问控制的基础功能：是否允许访问/当访问拒绝时如何处理等。

abstract boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception;
boolean onAccessDenied(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception;

    **isAccessAllowed：**表示是否允许访问。mappedValue就是[urls]配置中拦截器参数部分，如果允许访问返回true，否则false；
    **onAccessDenied**：表示当访问拒绝时是否已经处理。如果返回true表示需要继续处理；如果返回false表示该拦截器实例已经处理了，直接返回即可。
    一般在进行前后端分离时，需要使用自定义过滤器来处理跨域请求。
    案例：默认的roles过滤器会要求同时具备设定的角色才可以处理相应请求，可通过自定义过滤器，要求具备某种角色即可进行访问，而不是同时具备多种角色。

public class AnyRolesFilter extends AccessControlFilter {
     private String unauthorizedUrl = "/noPermission.html";
     private String loginUrl = "/login.html";
     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
         String[] roles = (String[])mappedValue;  
         if(roles == null) {  
             return true;//如果没有设置角色参数，默认成功  
         }  
         for(String role : roles) {  
             if(getSubject(request, response).hasRole(role)) {  
                 return true;  
             }  
         }  
     return false;//跳到onAccessDenied处理  
 }  
 @Override  
 protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
     Subject subject = getSubject(request, response);
     if (subject.getPrincipal() == null) {//表示没有登录，重定向到登录页面  
         saveRequest(request);  
         WebUtils.issueRedirect(request, response, loginUrl);
     } else {  
         if (StringUtils.hasText(unauthorizedUrl)) {//如果有未授权页面跳转过去
             WebUtils.issueRedirect(request, response, unauthorizedUrl);  
         } else {//否则返回401未授权状态码  
             WebUtils.toHttp(response).sendError(HttpServletResponse.SC_UNAUTHORIZED);
         }  
     }  
     return false;  
 }  
}

    @Bean
 public ShiroFilterFactoryBean shiroFilterFactoryBean(){
     ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
     factoryBean.setSecurityManager(defaultWebSecurityManager());
     //将自定义过滤器注册到shiro过滤器集合中
     Map<String, Filter> filters = factoryBean.getFilters();
     filters.put("anyRole",new AnyRolesFilter());
     factoryBean.setFilters(filters);
     //使用过滤器处理相应请求，白名单在前，黑名单在后
     LinkedHashMap<String, String> map = new LinkedHashMap<>();
     map.put("/user/login","anon");
     map.put("/user/register","anon");
     map.put("/user/logout","logout");
     map.put("/user/toRegister","anon");
     map.put("/user/toIndex","anon");
     //使用自定义过滤器处理请求，测试时如果没有相应角色，会跳转到unauthorizedUrl
     map.put("/user/haha","anyRole[admin,user]");
     map.put("/**","user");
     factoryBean.setFilterChainDefinitionMap(map);
     factoryBean.setLoginUrl("/user/toLogin");
     factoryBean.setUnauthorizedUrl("/user/toNoPermission");
     return factoryBean;
 }

6.5 认证实现

1. 在login.jsp中开发认证界面

    <form method="post" action="${pageContext.request.contextPath}/user/login">
        用户名：<input type="text" name="username"><br>
        密码  ：<input type="password" name="password"><br>
        <input type="submit" value="登录">
  </form>

2. 开发controller

@Controller
public class UserController {
    /**
     * 进行身份认证
     * @param username
     * @param password
     * @return
     */
    @PostMapping("/user/login")
    public String login(String username,String password){
        //在shiroFilter中配置了securityManager，会自动注入到securityUtils中
        Subject subject = SecurityUtils.getSubject();
        //创建令牌
        UsernamePasswordToken authenticationToken = new UsernamePasswordToken(username, password);
        //进行认证
        //在ShiroConfig中配置了认证的数据来源--CustomerRealm
        //因此，必须保证用户在页面提交的用户名和密码与CustomerRealm中设置的一致，才能通过认证。
        try {
            subject.login(authenticationToken);
            //认证通过，重定向到index.jsp
            return "redirect:/index.jsp";
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        }
        //认证未通过，重定向到login.jsp
        return "redirect:/login.jsp";
    }
}

3.开发realm中返回静态数据(未连接数据库)

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        //测试中使用指定数据，整合mybatis后再查询数据库获取
        if ("tom".equals(principal)) {
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,"123",this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }

4.启动项目以realm中定义静态数据进行认证

6.6 退出认证

1.开发index.jsp页面退出连接

<%@page contentType="text/html; UTF-8" pageEncoding="UTF-8" %>
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>系统管理页</title>
</head>
<body>
    <h1>欢迎登录**后台管理系统,<a href="${pageContext.request.contextPath}/user/logout">退出登录</a></h1>
    <ul>
        <li><a href="">用户管理</a></li>
        <li><a href="">类别管理</a></li>
        <li><a href="">商品管理</a></li>
        <li><a href="">订单管理</a></li>
        <li><a href="">物流管理</a></li>
    </ul>
</body>
</html>

2.开发controller

    @GetMapping("/user/logout")
    public String logout(){
        SecurityUtils.getSubject().logout();//退出登录
        return "redirect:/login.jsp";
    }

3.重启项目测试

6.7 MD5、Salt的认证实现

1.开发数据库注册

0.开发注册界面

    <h1>用户注册</h1>
    <form method="post" action="${pageContext.request.contextPath}/user/register">
        用户名：<input type="text" name="username"><br>
        密码  ：<input type="password" name="password"><br>
        <input type="submit" value="立即注册">
    </form>

1.修改shiro配置

    在ShiroConfig.java中放行对注册请求和注册页面的拦截。

        Map<String,String> map=new HashMap();
        map.put("/**","authc");
        map.put("/user/login","anon");
        map.put("/register.jsp","anon");
        map.put("/user/register","anon");
        //一般来说，对用户的操作都应该放行，所以可以使用map.put("/user/**","anon")代替所有对用户的操作
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

2.创建数据库及数据表

create database shiro;

user shiro;

create table t_user(
    id int(4) primary key auto_increment,
    username varchar(50) not null,
    password varchar(50) not null,
    salt varchar(255) not null
)

3.项目引入依赖

<!--mybatis相关依赖-->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.1.2</version>
</dependency>

<!--mysql-->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>


<!--druid-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.19</version>
</dependency>

4.配置application.yml配置文件

server:
  port: 8888
  servlet:
    context-path: /shiro

spring:
  mvc:
    view:
      suffix: .jsp
      prefix: /
  application:
    name: shiro
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shiro?characterEncoding=utf-8
    username: root
    password: root

mybatis:
  mapper-locations: classpath:com/woniu/mapper/*.xml
  type-aliases-package: com.woniu.domain

5.创建实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class User implements Serializable {
    private String id;
    private String username;
    private String password;
    private Date createTime;
    private Date lastUpdateTime;
}

6.创建DAO接口

//可在每个dao上单独加@Mapper注解，也可在启动类上加@MapperScan注解
@Mapper
public interface UserDao {
    void addUser(User user);
}

7.开发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.woniu.dao.UserDao">
    <insert id="addUser" parameterType="User" useGeneratedKeys="true" keyProperty="id">
        insert into t_user 
        values(#{id},#{username},#{password},#{salt},#{createTime},#{lastUpdateTime})
    </insert>
</mapper>

8.开发service接口

public interface UserService {
    void register(User user);
}

9.创建salt工具类

public class SaltUtil {
    /**
     * 生成salt的静态方法
     * @param n
     * @return
     */
    public static String getSalt(int n){
        char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()".toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            char aChar = chars[new Random().nextInt(chars.length)];
            sb.append(aChar);
        }
        return sb.toString();
    }
}

10.开发service实现类

@Service
@Transactional
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    @Override
    public void register(User user) {
        String salt = SaltUtil.getSalt(8);//获取随机盐
        user.setSalt(salt);//保存随机盐
        //对用户密码进行  md5 + salt + hash散列 加密
        Md5Hash md5Hash = new Md5Hash(user.getPassword(), salt,2048);
        user.setPassword(md5Hash.toHex());//设置加密后的密码
        Date createTime = new Date();
        user.setCreateTime(createTime);//用户注册时间
        user.setLastUpdateTime(createTime);//用户最后一次修改时间
        userDao.addUser(user);
    }
}

11.开发Controller

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 用户注册
     */
    @PostMapping("/user/register")
    public String register(User user){
        try {
            userService.register(user);
            return "redirect:/login.jsp";
        } catch (Exception e) {
            e.printStackTrace();
            return "redirect:/register.jsp";
        }
    }

    ......
}

12.启动项目测试注册

2.开发数据库认证

0.开发DAO

@Mapper
public interface UserDao {
    /**
     * 保存用户
     * @param user
     */
    void addUser(User user);

    /**
     * 根据用户名查询用户
     * @param username
     * @return
     */
    User findByUserName(String username);
}

1.开发mapper配置文件

    <select id="findByUserName" parameterType="string" resultType="User">
        select * from t_user where username=#{username}
    </select>

2.开发Service接口

public interface UserService {
    void register(User user);

    User findByUserName(String username);
}

3.开发Service实现类

    @Override
    public User findByUserName(String username) {
        return userDao.findByUserName(username);
    }

4.修改自定义realm

public class CustomerRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        //整合mybatis后再查询数据库获取
        User user = userService.findByUserName(principal);
        if (!ObjectUtils.isEmpty(user)) {//根据用户名查询得到的用户不为空
            if (user.getUsername().equals(principal)) {
                return new SimpleAuthenticationInfo(user.getUsername(),
                        user.getPassword(),
                        ByteSource.Util.bytes(user.getSalt()),
                        this.getName());
            }
        }
        return null;
    }
}

6.修改ShiroConfig中realm使用凭证匹配器以及hash散列

@Bean
public Realm realm(){
    //设置hashed凭证匹配器
    HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
    //使用md5加密
    hashedCredentialsMatcher.setHashAlgorithmName("md5");
    //设置散列次数
    hashedCredentialsMatcher.setHashIterations(2048);
    CustomerRealm customerRealm = new CustomerRealm();
    customerRealm.setCredentialsMatcher(hashedCredentialsMatcher);
    return customerRealm;
}

6.8 授权实现

1.授权

public class CustomerRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;
    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        String primaryPrincipal = (String) principalCollection.getPrimaryPrincipal();
        //测试数据
        if ("tom".equals(primaryPrincipal)) {
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            //授予角色 user admin
            simpleAuthorizationInfo.addRoles(Arrays.asList("user","product"));
           //授予权限字符串 
 simpleAuthorizationInfo.addStringPermissions(Arrays.asList("user:find","user:update"));    simpleAuthorizationInfo.addStringPermissions(Arrays.asList("product:find","product:update"));
            return simpleAuthorizationInfo;
        }
        return null;
    }

    ......
}

2.验证

shiro标签验证

......
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
......
        <shiro:hasAnyRoles name="user,admin">
            <li>
                <a href="">用户管理</a>
                <ul>
                    <shiro:hasPermission name="user:find">
                        <li><a href="">查询用户</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:create">
                        <li><a href="">新增用户</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:update">
                        <li><a href="">修改用户</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:delete">
                        <li><a href="">删除用户</a></li>
                    </shiro:hasPermission>
                </ul>
            </li>
        </shiro:hasAnyRoles>
        <shiro:hasAnyRoles name="type,admin">
            <li><a href="">类别管理</a></li>
        </shiro:hasAnyRoles>
        <shiro:hasAnyRoles name="product,admin">
            <li><a href="">商品管理</a></li>
        </shiro:hasAnyRoles>
        <shiro:hasAnyRoles name="order,admin">
            <li><a href="">订单管理</a></li>
        </shiro:hasAnyRoles>
        <shiro:hasAnyRoles name="logistics,admin">
            <li><a href="">物流管理</a></li>
        </shiro:hasAnyRoles>
......

代码验证

@Controller
public class ProductController {

    /**
     * 演示代码验证权限
     * @return
     */
    @GetMapping("/product/save")
    public String save(){
        Subject subject = SecurityUtils.getSubject();
        //判断角色
//        if (subject.hasRole("product")) {
//            return "redirect:/product.jsp";
//        }
        //判断权限字符串
        if (subject.isPermitted("product:find")) {
            return "redirect:/product.jsp";
        }
        return "redirect:/index.jsp";
    }
}

注解验证

@Controller
public class ProductController {
......
    /**
     * 演示注解授权
     * @return
     */
    //@RequiresPermissions("product:update") 注解权限字符串验证
    //@RequiresPermissions(value={"product:find","product:update"}) 可写多个，代表必须同时拥有
    //@RequiresRoles("product") 注解角色验证

    //logical是一个枚举，取值为AND或OR，OR表示value中任意拥有一个即可，AND表示必须同时拥有
    //@RequiresRoles(logical = Logical.OR,value = {"user","product","order"})
    //@RequiresPermissions(logical = Logical.OR,
    //        value = {"user:*:*","product:create:*","order:select:*"})
    @RequiresRoles("product")
    @RequiresPermissions("product:find")
    @GetMapping("/product/update")
    public String update(){
        return "redirect:/product.jsp";
    }
}

注：使用shiro注解验证时，需要提供对shiro注解的支持：

@Configuration
public class ShiroConfig {
    /*--------------------------------基本配置-----------------------------------*/
    //注册shiro过滤器
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);

        HashMap<String, String> filterChain = new HashMap<>();

        filterChain.put("/user/**","anon");
        filterChain.put("/js/**","anon");
        filterChain.put("/permission","anon");
        filterChain.put("/**","user");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChain);
        shiroFilterFactoryBean.setLoginUrl("/user/toLogin");
        return shiroFilterFactoryBean;
    }

    //注册安全管理器：web项目
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(Realm realm,CookieRememberMeManager cookieRememberMeManager){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager(realm);//配置自定义realm
        defaultWebSecurityManager.setRememberMeManager(cookieRememberMeManager);//配置rememberMe管理器
        return defaultWebSecurityManager;
    }

    //注册realm
    @Bean
    public Realm realm(){
        CustomerRealm customerRealm = new CustomerRealm();

        //设置hashed凭证匹配器
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        //使用md5加密
        hashedCredentialsMatcher.setHashAlgorithmName("md5");
        //设置散列次数
        hashedCredentialsMatcher.setHashIterations(2048);
        CustomerRealm customerRealm = new CustomerRealm();
        customerRealm.setCredentialsMatcher(hashedCredentialsMatcher);

        //开启缓存
        customerRealm.setCachingEnabled(true);
        customerRealm.setAuthenticationCachingEnabled(true);//开启认证缓存
        customerRealm.setAuthenticationCacheName("authenticationCache");
        customerRealm.setAuthorizationCachingEnabled(true);//开启授权缓存
        customerRealm.setAuthorizationCacheName("authorizationCache");

        customerRealm.setCacheManager(new EhCacheManager());//设置缓存管理器
        return customerRealm;
    }

    /*------------------------------rememberMe----------------------------------*/
    //注册rememberMe管理器，有rememberMe需求才配
    @Bean
    public CookieRememberMeManager cookieRememberMeManager(){
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        SimpleCookie rememberMe = new SimpleCookie("rememberMe");
        rememberMe.setMaxAge(7*24*60*60);
        cookieRememberMeManager.setCookie(rememberMe);
        cookieRememberMeManager.setCipherKey(Base64.decode("a1b2c3d4e5f6g7h8i9j10k=="));
        return cookieRememberMeManager;
    }

    /*---------------------------------shiro方言-----------------------------------*/
    //注册shiro方言，否则静态页面不识别shiro，使用thymeleaf模板后必须配置
    @Bean
    public ShiroDialect shiroDialect(){
        return new ShiroDialect();
    }
    /*---------------------------------shiro注解支持-------------------------------*/
    /**
     * 添加注解支持
     * DefaultAdvisorAutoProxyCreator是用来扫描上下文，
     * 寻找所有的Advistor(通知器），
     * 将这些Advisor应用到所有符合切入点的Bean中。
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        // 强制使用cglib，防止重复代理和可能引起代理出错的问题
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

 /**
        * 配置通知器，指定扫描对应注解的类
     * @param securityManager
     * @return
  */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager defaultWebSecurityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(defaultWebSecurityManager);
        return advisor;
    }

 /**
        * LifecycleBeanPostProcessor：
     * 将Initializable和Destroyable的实现类统一在其内部自动分别调用了Initializable.init()和Destroyable.destroy()方法，从而达到管理shiro bean生命周期的目的
     * @return
  */
    @Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

}

# shiro注解
    @RequiresAuthentication
    验证用户是否登录，等同于方法subject.isAuthenticated() 结果为true时。

    @RequiresUser
    验证用户是否被记忆，user有两种含义：
        一种是成功登录的：subject.isAuthenticated() 结果为true；
        另外一种是被记忆的：subject.isRemembered()结果为true。

    @RequiresGuest
    验证是否是一个guest的请求，与@RequiresUser完全相反。换言之，RequiresUser  == !RequiresGuest。此时subject.getPrincipal() 结果为null.

    @RequiresRoles
    例如：@RequiresRoles("aRoleName");
    void someMethod();
    如果subject中有aRoleName角色才可以访问方法someMethod。如果没有这个权限则会抛出异常AuthorizationException。

    @RequiresPermissions
    例如： @RequiresPermissions({"file:read", "write:aFile.txt"} )
    void someMethod();
    要求subject中必须同时含有file:read和write:aFile.txt的权限才能执行方法someMethod()。否则抛出异常AuthorizationException。

3.授权数据持久化（RBAC）

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_pers
-- ----------------------------
DROP TABLE IF EXISTS `t_pers`;
CREATE TABLE `t_pers` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `name` varchar(80) DEFAULT NULL,
  `url` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_role
-- ----------------------------
DROP TABLE IF EXISTS `t_role`;
CREATE TABLE `t_role` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `name` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_role_perms
-- ----------------------------
DROP TABLE IF EXISTS `t_role_perms`;
CREATE TABLE `t_role_perms` (
  `id` int(6) NOT NULL,
  `roleid` int(6) DEFAULT NULL,
  `permsid` int(6) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `username` varchar(40) DEFAULT NULL,
  `password` varchar(40) DEFAULT NULL,
  `salt` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_user_role
-- ----------------------------
DROP TABLE IF EXISTS `t_user_role`;
CREATE TABLE `t_user_role` (
  `id` int(6) NOT NULL,
  `userid` int(6) DEFAULT NULL,
  `roleid` int(6) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

SET FOREIGN_KEY_CHECKS = 1;

4.创建dao方法

 //根据用户名查询所有角色
User findRolesByUserName(String username);
//根据角色id查询权限集合
List<Perms> findPermsByRoleId(String id);

5.mapper实现

<resultMap id="userMap" type="User">
  <id column="uid" property="id"/>
  <result column="username" property="username"/>
  <!--角色信息-->
  <collection property="roles" javaType="list" ofType="Role">
    <id column="id" property="id"/>
    <result column="rname" property="name"/>
  </collection>
</resultMap>

<select id="findRolesByUserName" parameterType="String" resultMap="userMap">
  SELECT u.id uid,u.username,r.id,r.NAME rname
  FROM t_user u
  LEFT JOIN t_user_role ur
  ON u.id=ur.userid
  LEFT JOIN t_role r
  ON ur.roleid=r.id
  WHERE u.username=#{username}
</select>

<select id="findPermsByRoleId" parameterType="String" resultType="Perms">
  SELECT p.id,p.NAME,p.url,r.NAME
  FROM t_role r
  LEFT JOIN t_role_perms rp
  ON r.id=rp.roleid
  LEFT JOIN t_perms p ON rp.permsid=p.id
  WHERE r.id=#{id}
</select>

6.Service接口

//根据用户名查询所有角色
User findRolesByUserName(String username);
//根据角色id查询权限集合
List<Perms> findPermsByRoleId(String id);

7.Service实现

@Override
public List<Perms> findPermsByRoleId(String id) {
  return userDAO.findPermsByRoleId(id);
}

@Override
public User findRolesByUserName(String username) {
  return userDAO.findRolesByUserName(username);
}

8.修改自定义realm

public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //获取身份信息
        String primaryPrincipal = (String) principals.getPrimaryPrincipal();
        System.out.println("调用授权验证: "+primaryPrincipal);
        //根据主身份信息获取角色 和 权限信息
        UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
        User user = userService.findRolesByUserName(primaryPrincipal);
        //授权角色信息
        if(!CollectionUtils.isEmpty(user.getRoles())){
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            user.getRoles().forEach(role->{
                simpleAuthorizationInfo.addRole(role.getName());
                //权限信息
                List<Perms> perms = userService.findPermsByRoleId(role.getId());
                if(!CollectionUtils.isEmpty(perms)){
                    perms.forEach(perm->{
                        simpleAuthorizationInfo.addStringPermission(perm.getName());
                    });
                }
            });
            return simpleAuthorizationInfo;
        }
        return null;
    }
}

9.启动测试

6.9 使用CacheManager

1.Cache 作用

• Cache 缓存: 计算机内存中一段数据
• 作用: 用来减轻DB的访问压力,从而提高系统的查询效率
• 流程:

2.使用shiro中默认EhCache实现缓存

1.引入依赖

<!--引入shiro和ehcache-->
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-ehcache</artifactId>
  <version>1.5.3</version>
</dependency>

2.开启缓存

//3.创建自定义realm
    @Bean
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();
        //修改凭证校验匹配器
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        //设置加密算法为md5
        credentialsMatcher.setHashAlgorithmName("MD5");
        //设置散列次数
        credentialsMatcher.setHashIterations(1024);
        customerRealm.setCredentialsMatcher(credentialsMatcher);

        //开启缓存管理器
        customerRealm.setCachingEnabled(true);
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setCacheManager(new EhCacheManager());
        return customerRealm;
    }

3.启动刷新页面进行测试

• 注意:如果控制台没有任何sql展示说明缓存已经开启

  3.shiro中使用Redis作为缓存实现

  1.引入redis依赖

  <!--redis整合springboot-->
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>
  

  2.配置redis连接

  spring.redis.port=6379
  spring.redis.host=localhost
  spring.redis.database=0
  

  

  3.启动redis服务

  ➜  bin ls
  dump.rdb        redis-check-aof redis-cli       redis-server    redis.conf
  redis-benchmark redis-check-rdb redis-sentinel  redis-trib.rb
  ➜  bin ./redis-server redis.conf
  

  

  4.开发RedisCacheManager

  public class RedisCacheManager implements CacheManager {
    @Override
    public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException {
        System.out.println("缓存名称: "+cacheName);
        return new RedisCache<K,V>(cacheName);
    }
  }
  

  5.开RedisCache实现

  ```java public class RedisCache implements Cache {

  private String cacheName;

  public RedisCache() { }

  public RedisCache(String cacheName) {

    this.cacheName = cacheName;
  

  }

  @Override public V get(K k) throws CacheException {

    System.out.println("获取缓存:"+ k);
    return (V) getRedisTemplate().opsForHash().get(this.cacheName,k.toString());
  

  }

  @Override public V put(K k, V v) throws CacheException {

    System.out.println("设置缓存key: "+k+" value:"+v);
    getRedisTemplate().opsForHash().put(this.cacheName,k.toString(),v);
    return null;
  

  }

  @Override public V remove(K k) throws CacheException {

    return (V) getRedisTemplate().opsForHash().delete(this.cacheName,k.toString());
  

  }

  @Override public v remove(k k) throws CacheException {

    return (v) getRedisTemplate().opsForHash().delete(this.cacheName,k.toString());
  

  }

  @Override public void clear() throws CacheException {

    getRedisTemplate().delete(this.cacheName);
  

  }

  @Override public int size() {

    return getRedisTemplate().opsForHash().size(this.cacheName).intValue();
  

  }

  @Override public Set keys() {

    return getRedisTemplate().opsForHash().keys(this.cacheName);
  

  }

  @Override public Collection values() {

    return getRedisTemplate().opsForHash().values(this.cacheName);
  

  }

  private RedisTemplate getRedisTemplate(){

    RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    return redisTemplate;
  

  }

//封装获取redisTemplate
private RedisTemplate getRedisTemplate(){
    RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    return redisTemplate;
}

}

<a name="dba5a5a1"></a>
##### 6.启动项目测试发现报错
![image-20200530100850618](Shiro 实战教程.assets/image-20200530100850618.png)<br />![image-20200530100948598](Shiro 实战教程.assets/image-20200530100948598.png)

- 错误解释: **由于shiro中提供的simpleByteSource实现没有实现序列化,所有在认证时出现错误信息**
- 解决方案: **需要自动salt实现序列化**
   - 自定义salt实现序列化
```java
//自定义salt实现  实现序列化接口
public class MyByteSource extends SimpleByteSource implements Serializable {
    public MyByteSource(String string) {
        super(string);
    }
}

• 在realm中使用自定义salt

  @Override
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
  System.out.println("==========================");
  //根据身份信息
  String principal = (String) token.getPrincipal();
  //在工厂中获取service对象
  UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
  User user = userService.findByUserName(principal);
  if(!ObjectUtils.isEmpty(user)){
  return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(), 
                                   new MyByteSource(user.getSalt()),this.getName());
  }
  return null;
  }
  

• 

  7.再次启动测试,发现可以成功放入redis缓存

  

4. 加入验证码验证

0.开发页面加入验证码

• 开发控制器

  @RequestMapping("getImage")
  public void getImage(HttpSession session, HttpServletResponse response) throws IOException {
  //生成验证码
  String code = VerifyCodeUtils.generateVerifyCode(4);
  //验证码放入session
  session.setAttribute("code",code);
  //验证码存入图片
  ServletOutputStream os = response.getOutputStream();
  response.setContentType("image/png");
  VerifyCodeUtils.outputImage(220,60,os,code);
  }
  

• 放行验证码
  

• 开发页面
  

• 修改认证流程

  @RequestMapping("login")
    public String login(String username, String password,String code,HttpSession session) {
        //比较验证码
        String codes = (String) session.getAttribute("code");
        try {
            if (codes.equalsIgnoreCase(code)){
                //获取主体对象
                Subject subject = SecurityUtils.getSubject();
                    subject.login(new UsernamePasswordToken(username, password));
                    return "redirect:/index.jsp";
            }else{
                throw new RuntimeException("验证码错误!");
            }
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误!");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误!");
        }catch (Exception e){
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
        return "redirect:/login.jsp";
    }
  

• 修改salt不能序列化的问题

  //自定义salt实现  实现序列化接口
  public class MyByteSource implements ByteSource,Serializable {
  
    private  byte[] bytes;
    private String cachedHex;
    private String cachedBase64;
  
    //加入无参数构造方法实现序列化和反序列化
    public MyByteSource(){
  
    }
  
    public MyByteSource(byte[] bytes) {
        this.bytes = bytes;
    }
  
    public MyByteSource(char[] chars) {
        this.bytes = CodecSupport.toBytes(chars);
    }
  
    public MyByteSource(String string) {
        this.bytes = CodecSupport.toBytes(string);
    }
  
    public MyByteSource(ByteSource source) {
        this.bytes = source.getBytes();
    }
  
    public MyByteSource(File file) {
        this.bytes = (new MyByteSource.BytesHelper()).getBytes(file);
    }
  
    public MyByteSource(InputStream stream) {
        this.bytes = (new MyByteSource.BytesHelper()).getBytes(stream);
    }
  
    public static boolean isCompatible(Object o) {
        return o instanceof byte[] || o instanceof char[] || o instanceof String || o instanceof ByteSource || o instanceof File || o instanceof InputStream;
    }
  
    public byte[] getBytes() {
        return this.bytes;
    }
  
    public boolean isEmpty() {
        return this.bytes == null || this.bytes.length == 0;
    }
  
    public String toHex() {
        if (this.cachedHex == null) {
            this.cachedHex = Hex.encodeToString(this.getBytes());
        }
  
        return this.cachedHex;
    }
  
    public String toBase64() {
        if (this.cachedBase64 == null) {
            this.cachedBase64 = Base64.encodeToString(this.getBytes());
        }
  
        return this.cachedBase64;
    }
  
    public String toString() {
        return this.toBase64();
    }
  
    public int hashCode() {
        return this.bytes != null && this.bytes.length != 0 ? Arrays.hashCode(this.bytes) : 0;
    }
  
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (o instanceof ByteSource) {
            ByteSource bs = (ByteSource)o;
            return Arrays.equals(this.getBytes(), bs.getBytes());
        } else {
            return false;
        }
    }
  
    private static final class BytesHelper extends CodecSupport {
        private BytesHelper() {
        }
  
        public byte[] getBytes(File file) {
            return this.toBytes(file);
        }
  
        public byte[] getBytes(InputStream stream) {
            return this.toBytes(stream);
        }
    }
  }
  

8.Shiro整合springboot之thymeleaf权限控制

1.引入扩展依赖

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

2.页面中引入命名空间

• xmlns:shiro=”http://www.pollix.at/thymeleaf/shiro“

  <html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org"
      xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
  ......
  

  3.常见权限控制标签使用

  ```html

  Please login

Welcome back John! Not John? Click here to login.

Hello, , how are you today?

Hello, , how are you today?

Please login in order to update your credit card information.

Administer the system

Sorry, you are not allowed to developer the system.

You are a developer and a admin.

You are a admin, vip, or developer.

添加用户

Sorry, you are not allowed to delete user accounts.

You can see or add users.

You can see or delete users.

<a name="1ee2787c"></a>
### 4.加入shiro的方言配置

- 页面标签不起作用一定要记住加入方言处理
```java
@Bean(name = "shiroDialect")
public ShiroDialect shiroDialect(){
  return new ShiroDialect();
}

7.rememberMe

@Bean
    public CookieRememberMeManager cookieRememberMeManager(){
        CookieRememberMeManager cookie=new CookieRememberMeManager();
        SimpleCookie rememberMe=new SimpleCookie("rememberMe");
        rememberMe.setMaxAge(7*24*60*60);
        cookie.setCookie(rememberMe);
        cookie.setCipherKey(Base64.decode("a1b2c3d4e5f6h7j8k9l10=="));
        return cookie;
    }

 @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager webSecurityManager=new DefaultWebSecurityManager();
        webSecurityManager.setRealm(realm);
        webSecurityManager.setRememberMeManager(cookieRememberMeManager());
        return webSecurityManager;
    }