Shiro的基本使用

首发日期：2019-06-03

前言

在以往的权限管理中，我们的权限管理通常是有以下几个步骤： 1.创建用户，分配权限。 2.用户登录，权限拦截器拦截请求，识别当前用户登录信息 3.从权限表中判断是否拥有权限
从以上步骤中可以提取到以下三个问题。三个问题： > 1.如何让Shiro拦截请求。 > 在web开发中，Shiro会提供一个拦截器来对请求进行拦截。 > > 2.Shiro如何判断发起请求用户的身份？ > 在web开发中，会借助session来判断，如果禁用了session，那么可能需要重写一些方法。 > > 3.如何判断权限？ > Shiro使用realm来判断权限。
下面的也将以这三个问题为中心来描述Shiro。

Shiro的介绍

Shiro是一个开源的java安全（权限）框架，它能够实现身份验证、授权、加密和会话管理等功能。
Shiro是apache旗下的产品，它的官网是： shiro官网: Apache Shiro
Shiro不仅可以用于javaEE环境，也可以用于javaSE

Shiro功能

Authentication：身份认证，验证用户是否拥有某个身份。
Authorization: 权限校验，验证某个已认证的用户是否拥有某个权限。确定“谁”可以访问“什么”。
Session Management：会话管理，管理用户登录后的会话，
Cryptography：加密，使用密码学加密数据，如加密密码。
Web Support：Web支持，能够比较轻易地整合到Web环境中。
Caching：缓存，对用户的数据进行缓存，
Concurrency：并发，Apache Shiro支持具有并发功能的多线程应用程序，也就是说支持在多线程应用中并发验证。
Testing：测试，提供了测试的支持。
Run as ：允许用户以其他用户的身份来登录。
Remember me ：记住我

补充

同类的比较知名的安全框架还有spring security，Shiro的优点是比较简洁，功能虽然比不上Spring Security多样，但对于安全需求不多的时候可以使用Shiro。

HelloWorld

依赖包：

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!-- 这里有用到日志打印，所以引入 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.15</version>
        </dependency>

对于不同的场景有不同依赖包【可以参考这个http://shiro.apache.org/download.html#latestSource】
基础包是shiro-core，这里仅作基础示例所以仅仅导入这个包。

示例代码

【一些代码可以参考https://github.com/apache/shiro/tree/master/samples/quickstart】
1.src/main/resources/shiro.ini的代码:

# -----------------------------------------------------------------------------
# users用来定义用户
[users]
# 用户名 = 密码,角色1,角色2...
admin = secret, admin
guest = guest, guest
aa = 123456, guest
# -----------------------------------------------------------------------------
# roles用来定义角色
[roles]
# 角色 = 权限 (* 代表所有权限)
admin = *
# 角色 = 权限 (* 代表所有权限)
guest = see
aa = see

2.src/main/com/demo/ShiroDemo的代码：

package com.demo;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ShiroDemo {
    private static final Logger log = LoggerFactory.getLogger(ShiroDemo.class);
    public static void main(String[] args) {
        //1.创建SecurityManagerFactory
        IniSecurityManagerFactory factory =
                new IniSecurityManagerFactory("classpath:shiro.ini");
        //2.获取SecurityManager,绑定到SecurityUtils中
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        //3.获取一个用户识别信息
        Subject currentUser = SecurityUtils.getSubject();
        //4.判断是否已经身份验证
        if (!currentUser.isAuthenticated()) {
            // 4.1把用户名和密码封装为 UsernamePasswordToken 对象
            UsernamePasswordToken token = new UsernamePasswordToken("guest", "guest");
            // 4.2设置rememberme
            token.setRememberMe(true);
            try {
                // 4.3登录.
                currentUser.login(token);
            }
            catch (UnknownAccountException uae) { //用户不存在异常
                log.info("****---->用户名不存在： " + token.getPrincipal());
                return;
            }
            catch (IncorrectCredentialsException ice) {// 密码不匹配异常
                log.info("****---->" + token.getPrincipal() + " 的密码错误!");
                return;
            }
            catch (LockedAccountException lae) {// 用户被锁定
                log.info("****---->用户 " + token.getPrincipal() + " 已被锁定");
            }
            catch (AuthenticationException ae) { // 其他异常，认证异常的父类
                log.info("****---->用户" + token.getPrincipal() + " 验证发生异常");
            }
        }

        // 5.权限测试：
        //5.1判断用户是否有某个角色
        if (currentUser.hasRole("guest")) {
            log.info("****---->用户拥有角色guest!");
        } else {
            log.info("****---->用户没有拥有角色guest");
            return;
        }
        //5.2判断用户是否执行某个操作的权限
        if (currentUser.isPermitted("see")) {
            log.info("****----> 用户拥有执行此功能的权限");
        } else {
            log.info("****---->用户没有拥有执行此功能的权限");
        }

        //6.退出
        System.out.println("****---->" + currentUser.isAuthenticated());
        currentUser.logout();
        System.out.println("****---->" + currentUser.isAuthenticated());

    }
}

代码解析

解析一下上面的代码做了什么：

对于shiro.ini：

1.在[users]标签下以用户名 = 密码,角色1,角色2...的格式创建了用户
2.在[roles]标签下以角色 = 权限 (* 代表所有权限)的格式为用户分配了角色

对于ShiroDemo.java:

1.使用shiro.ini来获取了IniSecurityManagerFactory
2.通过IniSecurityManagerFactory获取SecurityManager,并绑定到SecurityUtils中
3.使用SecurityUtils获取一个用户识别信息Subject
4.对Subject对象判断是否已经身份验证(Authenticated)
5.将用户名和密码封装成UsernamePasswordToken对象，调用Subject对象的login方法来进行登录
6.登录成功后，调用Subject对象的hasRole方法来判断用户是否拥有某个角色
7.调用Subject对象的isPermitted方法来判断用户是否拥有某个行为
8.调用Subject对象的logout方法来退出。

补充

上面展示了一个”登录-权限验证-退出“的流程。但上面的一些代码还是硬编码的，比如说上面的用户名和密码还是从ini表中获取的，比如说上面的权限信息还是从ini中获取的，这些问题都是需要解决的，下面会进行解决。

一些概念

先来了解一些概念。

Application Code：代表着应用，应用使用Subject来标识自己的身份，以及使用Subject来进行认证和授权。
Subject：代表着“当前用户”。
Shiro SecurityManager：应用使用Subject来进行认证和授权，实际上执行认证和授权的是SecurityManager
Realm：SecurityManager的认证和授权需要使用Realm，Realm负责获取用户的权限和角色等信息，再返回给SecurityManager来进行判断。
【下图是对这些概念的补充】
Authenticator：认证器，对用户身份进行认证的。
Authorizer：授权器，对用户进行授权的。用来判断用户是否拥有某个权限。
Realms：补充上面Realm的内容：Realm是可以有多个的。用户的认证和授权都需要Realm，也就是说Authenticator和Authorizer的实际操作还是交给了Realm
CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的
Cryptography ：加密模块，提供对”密码“的加密等功能。

Realm

Realm是真正负责处理认证和授权的组件。
SecurityManager要完成认证，需要Realm返回一个AuthenticationInfo，AuthenticationInfo会携带存储起来的正确的用户认证信息，用来与用户提交的信息进行比对，如果信息不匹配，那么会认证失败。
SecurityManager要完成授权，需要Realm返回一个AuthorizationInfo

认证

下面的例子是以继承了AuthenticatingRealm的自定义Realm来实现自定义认证。
认证依赖于方法doGetAuthenticationInfo，需要返回一个AuthenticationInfo，通常返回一个他的子类SimpleAuthenticationInfo，构造方法的第一个参数是用户名，第二个是验证密码，第三个是当前realm的className。

package com.demo.realms;

import org.apache.shiro.authc.*;
import org.apache.shiro.realm.AuthenticatingRealm;

public class MyRealm extends AuthenticatingRealm {
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)  {
        System.out.println("MyRealm认证中---->用户："+token.getPrincipal());
        // 可以从token中获取用户名来从数据库中查询数据
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String password="123456";// 假设这是从数据库中查询到的用户密码
        // 创建一个SimpleAuthenticationInfo，第一个参数是用户名，第二个是验证密码，第三个是当前realm的className
        // 验证密码会与用户提交的密码进行比对
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(upToken.getUsername(),password,this.getName());
        return info;
    }
}

当创建了一个Realm之后，需要告诉SecurityManager,所以在shiro.ini中配置：

# -------------------------------------------------------------------
[main]
myRealm = com.demo.realms.MyRealm
# --------由于自定义认证，所以去除users,roles------------------------

这样子就可以进行自定义认证了，在上面的用户密码中都设置了"123456"，所以如果输入的密码不正确都会认证失败。但上面没有设置授权，所以代码中要去掉授权的判断。

授权

下面的例子是以继承了AuthorizingRealm的自定义Realm来实现自定义认证和自定义授权。
授权依赖于方法doGetAuthorizationInfo，需要返回一个AuthorizationInfo，通常返回一个他的子类SimpleAuthorizationInfo。构造SimpleAuthorizationInfo可以空构造，也可以传入一个Set<String> roles来构造。

package com.demo.realms;

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 java.util.HashSet;
import java.util.Set;

public class RealmForDouble extends AuthorizingRealm {
//    授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // 1. 获取授权的用户
        Object principal = principals.getPrimaryPrincipal();
        System.out.println("RealmForDouble授权中---->用户："+principal);
        //2.下面使用Set<String> roles来构造SimpleAuthorizationInfo
        SimpleAuthorizationInfo info = null;
//        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        Set<String> roles = new HashSet<>();
        if ("admin".equals(principal)){
            roles.add("admin"); // 假设这个角色是从数据库中查出的
            // 如果SimpleAuthorizationInfo实例化了，
            // 可以这样来加角色，行为需要这样添加
            // 角色可以传构造函数来实例化SimpleAuthorizationInfo
//            info.addRole("admin");
//            info.addStringPermission("*");
        }
        if ("guest".equals(principal)){
            roles.add("guest");
        }
        info = new SimpleAuthorizationInfo(roles);
        return info;
    }

//    认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("RealmForDouble认证中---->用户："+token.getPrincipal());
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String password="123456";// 假设这是从数据库中查询到的用户密码
        // 创建一个SimpleAuthenticationInfo，第一个参数是用户名，第二个是验证密码，第三个是当前realm的className
        // 验证密码会与用户提交的密码进行比对
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(upToken.getUsername(),password,this.getName());
        return info;
    }
}

ini文件中也需要对应修改：

# -------------------------------------------------------------------
[main]
myRealm = com.demo.realms.RealmForDouble
# --------由于自定义认证，所以去除users,roles------------------------

这样子就可以进行自定义认证和授权了，上面的认证信息和授权信息都是可以修改成从数据库中获取的。

几个父类：

AuthorizingRealm：可以同时认证和授权。
AuthenticatingRealm：用于认证。
Realm：既可以用于认证也可以用于授权。

几个方法

有好几个父类，怎么判断他们能否进行认证或授权呢？

认证依赖于方法doGetAuthenticationInfo
授权依赖于方法doGetAuthorizationInfo
supports(AuthenticationToken token)方法可以处理非UsernamePasswordToken的情况。

异常

当认证错误时会抛出异常，下面列举一下常见的异常。

UnknownAccountException：用户不存在的异常
ExcessiveAttemptsException：登录失败次数过多的异常
IncorrectCredentialsException：密码不匹配的异常
LockedAccountException：用户已被锁定的异常
ExpiredCredentialsException：用户登录凭证已过期的异常。
AuthenticationException：身份认证异常的基类。

集成于Spring MVC

依赖包

    <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>
        <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>4.2.4.RELEASE</version>
        </dependency>

        <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-webmvc</artifactId>
              <version>4.2.4.RELEASE</version>
        </dependency>

          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-jdbc</artifactId>
              <version>4.2.4.RELEASE</version>
          </dependency>

          <dependency>
              <groupId>javax.servlet</groupId>
              <artifactId>jstl</artifactId>
              <version>1.2</version>
              <scope>runtime</scope>
          </dependency>

          <dependency>
              <groupId>javax.servlet</groupId>
              <artifactId>javax.servlet-api</artifactId>
              <version>3.1.0</version>
              <scope>provided</scope>
          </dependency>
          <dependency>
              <groupId>org.slf4j</groupId>
              <artifactId>slf4j-log4j12</artifactId>
              <version>1.6.1</version>
          </dependency>
          <dependency>
              <groupId>log4j</groupId>
              <artifactId>log4j</artifactId>
              <version>1.2.15</version>
          </dependency>

          <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-ehcache</artifactId>
              <version>1.3.2</version>
          </dependency>
          <dependency>
              <groupId>net.sf.ehcache</groupId>
              <artifactId>ehcache-core</artifactId>
              <version>2.4.3</version>
          </dependency>

          <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-core</artifactId>
              <version>1.3.2</version>
          </dependency>
          <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-spring</artifactId>
              <version>1.3.2</version>
          </dependency>
          <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-web</artifactId>
              <version>1.3.2</version>
          </dependency>

  </dependencies>

步骤

1.先配置Shiro拦截器：

  <filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
      <param-name>targetFilterLifecycle</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>

  <filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

2.匹配SpringMVC的DispatcherServlet：

  <servlet>
    <servlet-name>spring</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>spring</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

3.配置Spring的ContextLoaderListener:

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

4.配置springmvc.xml【springmvc的配置文件】：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <context:component-scan base-package="com.progor"></context:component-scan>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

    <mvc:annotation-driven></mvc:annotation-driven>
    <mvc:default-servlet-handler/>

</beans>

5.在applicationContext.xml中配置Shiro：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

	<!--1. 配置 SecurityManager!-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
		<!--缓存管理器-->
        <property name="cacheManager" ref="cacheManager"/>
		<!--realms-->
        <property name="realms">
            <list>
                <ref bean="jdbcRealm"/>
            </list>
        </property>
    </bean>

	<!--2. 配置 CacheManager缓存管理器.-->
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
		<!--缓存配置文件（这里暂不涉及，可以随便拷贝一个）-->
        <property name="cacheManagerConfigFile" value="classpath:ehcache.xml"/>
    </bean>

	<!--3. 配置 Realm-->
    <bean id="jdbcRealm" class="com.progor.realms.MyRealm">
    </bean>

	<!--4. 配置 LifecycleBeanPostProcessor，用来管理shiro一些bean的生命周期-->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

	<!--5. 启用shiro 的注解。但必须在配置了 LifecycleBeanPostProcessor 之后才可以使用-->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
          depends-on="lifecycleBeanPostProcessor"/>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

	<!--6. 配置 ShiroFilter.-->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="/login.jsp"/>
        <property name="successUrl" value="/list.jsp"/>
        <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
        <property name="filterChainDefinitions">
            <value>
                /login.jsp = anon
                /shiro/login = anon
                /shiro/logout = logout
                /** = authc
            </value>
        </property>
    </bean>
</beans>

6.创建控制器来接受登录请求,执行Shiro认证：

package com.progor.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/shiro")
public class UserController {

    @RequestMapping("/login")
    public String login(String username,String password){
        System.out.println(username+":"+password);
        Subject currentUser = SecurityUtils.getSubject();
        if (!currentUser.isAuthenticated()) {
            UsernamePasswordToken token = new UsernamePasswordToken(username, password);
            token.setRememberMe(true);
            try {
                currentUser.login(token);
            }
            catch (AuthenticationException ae) {
                System.out.println("登录失败: " + ae.getMessage());
            }
        }
        return "redirect:/admin.jsp";
    }
    @RequestMapping("/logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        System.out.println("退出成功");
        return "redirect:/login.jsp";
    }
}

7.创建realm:

package com.progor.realms;

import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthenticatingRealm;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

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

public class MyRealm extends AuthorizingRealm {
    //    授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        Object principal = principals.getPrimaryPrincipal();
        System.out.println("RealmForDouble授权中---->用户："+principal);
        SimpleAuthorizationInfo info = null;
        Set<String> roles = new HashSet<>();
        if ("admin".equals(principal)){
            roles.add("admin");
        }
        if ("guest".equals(principal)){
            roles.add("guest");
        }
        info = new SimpleAuthorizationInfo(roles);
        return info;
    }
    //    认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("RealmForDouble认证中---->用户："+token.getPrincipal());
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String password="123456";// 假设这是从数据库中查询到的用户密码
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(upToken.getUsername(),password,this.getName());
        return info;
    }
}

8.创建几个jsp，用于权限测试：
一个用于登录的login.jsp，一个用于验证登录成功的admin.jsp。【预期结果是如果未登录，那么访问admin.jsp会重定向到login.jsp】
login.jsp:

	<form action="shiro/login" method="POST">
		username: <input type="text" name="username"/>
		<br><br>
		password: <input type="password" name="password"/>
		<br><br>
		<input type="submit" value="Submit"/>
	</form>

admin.jsp:

<body>
    <p>这是admin.jsp</p>
    <a href="shiro/logout">退出</a>
</body>

9.配置ehcache.xml,可以参考https://github.com/apache/shiro/blob/master/samples/spring-mvc/src/main/resources/ehcache.xml

代码解析

1.配置ShiroFilter是为了让ShiroFilter能够拦截请求来进行权限判断。
2.applicationContext中配置的Shiro请参考注释。
3.ehcache.xml是缓存管理器的配置文件。

补充

上述的代码简略地演示了在Spring环境中Shiro的运行流程。下面将会对一些细节进行描述。

ShiroFilter拦截

上面的ShiroFilter中有如下图的代码

这主要是用来定义ShiroFilter拦截哪些请求，以及怎么拦截请求的。

拦截器链

在上图中，左边是url，右边是拦截器。
常见的拦截器有：

anon：任何人都可以访问
authc：只有认证后才可以访问
logout：只有登录后才可以访问
roles[角色名]：只有拥有特定角色才能访问，例如/admin.jsp = roles[user]
perms["行为"]：只有拥有某种行为的才能访问，例如/admin/deluser = prems["user:delete"]
想了解更多拦截器，可以参考shiro.apache.org/web.html#default-filters

url匹配

在上图中，有用到/**，这是代表所有请求，是为了拦截其余未定义拦截规则的请求。
其实这透露了url匹配是从上到下的，比如login.jsp由于前面定义了/login.jsp = anon，所以就不会交给/**来拦截了。
另外，是可以有多个拦截器的，所以/admin/** = authc, roles[administrator]也是可以的。

url属性

上面的ShiroFilter还配置了下图的属性，这是用来定义发生一些情况时跳转到哪个页面的。

比如配置了loginUrl,那么发起未认证的请求都会跳转到loginUrl
successUrl是用来定义登录成功后调整到哪个页面（如果controller跳转了视图那么这个失效）
unauthorizedUrl是用来定义访问不是自己权限的时跳转到哪个页面（普通的authc不会触发，roles会触发。）。

拦截器链的自定义

在上面都是使用硬编码的方式来定义拦截器链。下面将解决这个硬编码问题
一种方法是使用FilterChainResolver来处理，这里使用map的方式来处理。
定义一个类，核心方法是返回一个LinkedHashMap【有序是为了确保从上到下匹配】：

package com.progor.utils;
import java.util.LinkedHashMap;

public class FilterChainMap {
    // 使用静态工厂
    public static LinkedHashMap<String, String> getFilterChainMap(){
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        // 下面的数据可以从数据库中查询出来。
        map.put("/login.jsp", "anon");
        map.put("/shiro/login", "anon");
        map.put("/shiro/logout", "logout");
        map.put("/admin.jsp", "authc");
        map.put("/**", "authc");
        return map;
    }
}

修改applicationContext.xml:

    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="/login.jsp"/>
        <property name="successUrl" value="/list.jsp"/>
        <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
        <property name="filterChainDefinitionMap" ref="filteChainMap"></property>
        <!--去掉filterChainDefinitions-->
    </bean>
    <!--核心是获取这个map，由于使用了静态工厂，所以这样定义这个bean-->
    <bean id="filteChainMap"  class="com.progor.utils.FilterChainMap" factory-method="getFilterChainMap" ></bean>

补充：

上面讲述了ShiroFilter的配置，解决了请求的拦截问题。

密码加密

在上面的密码比对中，都是使用明文来比对。
而通常来说，被存储起来的用户密码通常都是加密后的。也就是说，在使用SimpleAuthenticationInfo返回的认证信息时候，里面的密码信息是被加密过的，如果我们直接拿用户提交的明文密码匹配的话就会匹配失败，所以我们应该还需要告诉Shiro使用什么加密方式来进行密码比较。
在Shiro中，使用credentialsMatcher来解决这个问题。

算法加密

在配置realm的时候，可以定义一个credentialsMatcher属性，例如：

    <bean id="jdbcRealm" class="com.progor.realms.MyRealm">
        <property name="credentialsMatcher">
            <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                <!--定义加密的算法-->
                <property name="hashAlgorithmName" value="MD5"></property>
            </bean>
        </property>
    </bean>

多重加密

密码加密一次后可以得到一串hash值，但还可以进行多次加密来提高安全性。

    <bean id="jdbcRealm" class="com.progor.realms.MyRealm">
        <property name="credentialsMatcher">
            <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                <!--定义加密的算法-->
                <property name="hashAlgorithmName" value="MD5"></property>
                <!--定义加密的次数-->
                <property name="hashIterations" value="1024"></property>
            </bean>
        </property>
    </bean>

盐值加密

除了多重加密，还可以加入一个”盐值“来进行加密。一个人的名字可能是会重复的，但如果带上他的身份证的话，那么这个人就是特定唯一的。密码也是如此，直接将密码进行加密可能还是比较容易分析出来的（网上有一些md5的密码库，常见的加密结果很容易查找出来），但如果加入一个具有比较罕见的参数来进行加密的话，那么得到的结果就会难以解析了。
盐值由于不是每一个加密都是一样的，所以不能在realm中设置，需要在返回AuthenticationInfo时带上，这样securityManager就会对提交的明文密码依据加密算法、加密次数和盐值来进行加密后再与AuthenticationInfo中的密码进行比对。

    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("RealmForDouble认证中---->用户："+token.getPrincipal());
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String password="e10adc3949ba59abbe56e057f20f883e";// md5(123456)
        String salt = "lilei";//假设这个盐值是从数据库中查出的
        ByteSource credentialsSalt = ByteSource.Util.bytes(salt);
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(upToken.getUsername(),password,credentialsSalt,this.getName());
        return info;
    }

多realm认证

realm是可以有多个的。
多个realm代表可以使用不同来源的认证信息来进行用户认证。【适用于一些需要从多个来源查询认证信息的情况】

多个realm的配置

上面已经讲述过realm的定义方法了，所以这里主要讲怎么让Shiro知道这多个realm。
只需要把新的realm配置成bean，并告诉securityManager即可。

    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="cacheManager" ref="cacheManager"/>
        <property name="realms">
            <list>
                <ref bean="jdbcRealm"/>
                <ref bean="secondRealm"/>
            </list>
        </property>
    </bean>
    <!--省略其他配置 -->
    <bean id="jdbcRealm" class="com.progor.realms.MyRealm">
        <property name="credentialsMatcher">
            <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                <property name="hashAlgorithmName" value="MD5"></property>
                <property name="hashIterations" value="1024"></property>
            </bean>
        </property>
    </bean>
    <bean id="secondRealm" class="com.progor.realms.SecondRealm"></bean>

对于上面的多个realm的认证，你可以尝试两个地方使用不同的密码来进行测试，借助sysout的话你会发现确实经过了两个realm.

认证策略

对于多个realm的默认的认证策略是只要其中一个通过了即可认证通过，也就是说一个密码不匹配，一个密码匹配，最终的结果将会是认证通过。
这个认证策略是可以修改的，需要对authenticator认证器进行配置。
- FirstSuccessfulStrategy：只要有一个 Realm 验证成功即可，只返回第一个 Realm 身份验证成功的认证信息，其他的忽略；
- AtLeastOneSuccessfulStrategy：只要有一个 Realm 验证成功即可，和 FirstSuccessfulStrategy不同，返回所有 Realm 身份验证成功的认证信息；
- AllSuccessfulStrategy：所有 Realm 验证成功才算成功，且返回所有 Realm 身份验证成功的认证信息，如果有一个失败就失败了。
  可以在applicationContext.xml中配置authenticator来设置认证策略。

    <bean id="authenticator"
          class="org.apache.shiro.authc.pam.ModularRealmAuthenticator">
        <property name="authenticationStrategy">
            <bean class="org.apache.shiro.authc.pam.AllSuccessfulStrategy"></bean>
        </property>
    </bean>

使用上述的代码后，需要所有的realm都验证成功才能认证成功。

授权

上面讲了权限拦截，下面讲一下怎么给请求/页面/业务来设置权限。

拦截链式

第一种是上面展示的使用拦截器链的方式，这种方式可以拦截一些请求/页面的非法权限操作。

编程式

编程式就是在代码中使用hasRole或isPermitted等方法来进行权限判断。

    @RequestMapping("/deluser")
    public String deluser(){
        Subject subject = SecurityUtils.getSubject();
        if (subject.hasRole("admin")){
            //一系列操作....
            System.out.println("执行了删除用户的操作");
            return "redirect:/admin.jsp";
        }else{
            System.out.println("你没有权限执行");
            return "redirect:/unauthorized.jsp";
        }
    }

除了hashRole，常见的方法还有：

hasRoles(List<String> roleIdentifiers)：拥有List中的所有角色才返回true
hasAllRoles(Collection<String> roleIdentifiers)：拥有集合中的所有角色才返回true
isPermitted(String... permissions)：是否拥有某个行为(支持传入多个参数)

注解式

注解式就是使用注解来进行权限管理。【这些注解不能用在controller中】

public class UserService {
    @RequiresRoles("admin") // 需要角色admin
    public void deluser(){
        System.out.println("执行了删除用户的操作");
    }
}

除了·@RequiresRoles("admin")，常见的注解还有：

@RequiresPermissions():是否拥有某个权限
注意，注解的使用需要以下两个bean:

<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
    <property name="securityManager" ref="securityManager"/>
</bean>

补充

除此之外，还可以在jsp中进行授权，这将在后面再讲。

shiro标签

也可以在jsp中进行授权。

首先导入标签库：
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>

<shiro:guest></shiro:guest>：当用户没进行认证时，显示标签中的内容。
<shiro:user></shiro:user>：当用户进行认证了，显示标签中的内容。
<shiro:authenticated></shiro:authenticated>：当用户已经认证时，显示标签中的内容。
<shiro:notAuthenticated></shiro:notAuthenticated>：当用户未认证的时候显示标签中的内容（包括“remember me”的时候）
<shiro:principal />:用来获取用户凭证(用户名等)(从AuthenticationInfo中获取)，标签所在的位置将被替换成凭证信息
<shiro:principal property="username" />:如果存入的用户凭证是一个对象，那么可以使用property指定获取这个对象中的属性。
<shiro:hasRole name="角色"></shiro:hasRole>:拥有指定角色，将显示标签中的内容。
<shiro:hasAnyRoles name="角色1,角色2..."></shiro:hasAnyRoles>：只要拥有多个角色中的一个就显示标签中的内容。
<shiro:lacksRole name="角色"></shiro:lacksRole>：没有某个角色将不显示标签中的内容
<shiro:hasPermission name="行为"></shiro:hasPermission>：如果拥有某个行为的权限，那么显示标签中的内容
<shiro:lacksPermission name="行为"></shiro:lacksPermission>：如果没有拥有某个行为，那么显示标签中内容

示例

<!-- 一个未登录的场景 -->
<shiro:guest>
    Hi there!  Please <a href="login.jsp">Login</a> or <a href="signup.jsp">Signup</a> today!
</shiro:guest>

<!-- 已登录过，准备切换其他用户的场景 -->
<shiro:user>
    Welcome back John!  Not John? Click <a href="login.jsp">here<a> to login.
</shiro:user>

<!-- 显示登录用户的用户名的场景 -->
Hello, <shiro:principal/>, how are you today?

<!-- 用户已经认证通过的场景 -->
<shiro:authenticated>
    <a href="/logout">退出</a>.
</shiro:authenticated>

<!-- 拥有某个角色的场景 -->
<shiro:hasRole name="administrator">
    <a href="createUser.jsp">创建用户</a>
</shiro:hasRole>

<!-- 拥有某个行为的场景 -->
<shiro:hasPermission name="user:create">
    <a href="createUser.jsp">创建用户</a>
</shiro:hasPermission>

remember me

remember me 主要用于再次访问时仍然保留认证状态的场景。例如，离开某个网站后，两三天再打开仍然保留你的登录信息。

setRememberMe

remember me的功能的一个前提是在认证时使用了setRememberMe :

为true才会“记住我”。

rememberme权限级别

记住我的权限并不是authc，而是user【用户已经身份验证/记住我】
所以做实验的要记得修改拦截器链。

参数设置

maxAge:过期时间
httpOnly:禁止使用js脚本读取到cookie信息
【其他的不太常用，有兴趣的自查。还有domain之类的】
一种配置方法：

<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="cacheManager" ref="cacheManager"/>
        <property name="realms">
            <list>
                <ref bean="jdbcRealm"/>
            </list>
        </property>
        <property name="rememberMeManager" ref="rememberMeManager"/>
    </bean>
    
    <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
        <constructor-arg value="rememberMe"/><!-- cookie的名称 -->
        <property name="httpOnly" value="true"/>
        <property name="maxAge" value="60"/><!-- 过期时间：60s -->
    </bean>

    <bean id="rememberMeManager"  class="org.apache.shiro.web.mgt.CookieRememberMeManager">
        <property name="cookie" ref="rememberMeCookie"/>
    </bean>

第二种配置方法：

    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="cacheManager" ref="cacheManager"/>
        <property name="realms">
            <list>
                <ref bean="jdbcRealm"/>
            </list>
        </property>
        <property name="rememberMeManager.cookie.maxAge" value="15"/>
    </bean>

补充

remember借助了cookie来实现记住登录状态，但这是不太安全的，因为（黑客）把cookie窃取了也能进行登录。

结语

这里仅仅只是“开了个门”，Shiro的世界还有很多广阔的地方。比如会话管理、单点登录【这些什么时候有空再写吧】
如果你想了解更多，可以参考Shiro官方参考手册http://shiro.apache.org/reference.html;
除此之外，张开涛的Shiro的PDF也是可以值得一看的。

相关阅读:
SerializationUtility
ExtendHelper
AutoTransformHandler
Parameter Config
Tools Function
谈谈对C#中反射的一些理解和认识(上)
WPF程序中App.Config文件的读与写
 WPF实现Windows资源管理器(附源码)
安装VC++2015运行库时出现0x80240037错误
 对C#调用C++的dll的一点思考
原文地址：https://www.cnblogs.com/progor/p/10970971.html