权限控制框架-shiro

最新推荐文章于 2024-08-05 19:20:23 发布

hyp1204

最新推荐文章于 2024-08-05 19:20:23 发布

阅读量489

点赞数

分类专栏：权限控制shiro

本文链接：https://blog.csdn.net/huoyunp/article/details/78861286

版权

权限控制shiro 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

一。 shiro简介
Apache Shiro是Java的一个安全框架。目前，使用Apache Shiro的人越来越多，因为它相当简单，对比Spring Security，可能没有Spring Security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的Shiro就足够了。对于它俩到底哪个好，这个不必纠结，能更简单的解决项目问题就好了。
本教程只介绍基本的Shiro使用，不会过多分析源码等，重在使用。

Shiro可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环境。Shiro可以帮助我们完成：认证、授权、加密、会话管理、与Web集成、缓存等。这不就是我们想要的嘛，而且Shiro的API也是非常简单；其基本功能点如下图所示：

这里写图片描述

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

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

接下来我们分别从外部和内部来看看Shiro的架构，对于一个好的框架，从外部来看应该具有非常简单易于使用的API，且API契约明确；从内部来看的话，其应该有一个可扩展的架构，即非常容易插入用户自定义实现，因为任何框架都不能满足所有需求。

首先，我们从外部来看Shiro吧，即从应用程序角度的来观察如何使用Shiro完成工作。如下图：

这里写图片描述

Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；*可以把Subject认为是一个门面；SecurityManager才是实际的执行者；
SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器；
Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。

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

接下来我们来从Shiro内部来看下Shiro的架构，如下图所示：
这里写图片描述

Subject：主体，可以看到主体可以是任何可以与应用交互的“用户”；
SecurityManager：相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher；是Shiro的心脏；所有具体的交互都通过SecurityManager进行控制；它管理着所有Subject、且负责进行认证和授权、及会话、缓存的管理。
Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得Shiro默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了；
Authrizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；
Realm：可以有1个或多个Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是JDBC实现，也可以是LDAP实现，或者内存实现等等；由用户提供；注意：Shiro不知道你的用户/权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的Realm；
SessionManager：如果写过Servlet就应该知道Session的概念，Session呢需要有人去管理它的生命周期，这个组件就是SessionManager；而Shiro并不仅仅可以用在Web环境，也可以用在如普通的JavaSE环境、EJB等环境；所有呢，Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据；这样的话，比如我们在Web环境用，刚开始是一台Web服务器；接着又上了台EJB服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到Memcached服务器）；
**SessionDAO：**DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；比如想把Session放到Memcached中，可以实现自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能；
CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能
Cryptography：密码模块，Shiro提高了一些常见的加密组件用于如密码加密/解密的。

常用的操作
ini文件在src/main/resources目录下
ini配置权限信息

# =======================  
# Shiro INI configuration  
# =======================
[main]  
[users]
# 设置用户信息  
# 语法是 username = password, roleName1, roleName2, …, roleNameN  
admin = 123456,role1
[roles]
# 角色信息和角色拥有的权限  
#语法是 rolename = permissionDefinition1, permissionDefinition2, …, permissionDefinitionN  
#权限的语法 * 表示所有权限  一般语法是 权限类型.权限动作.权限的资源id  比如  user:delete:1 表示拥有删除1号用户的权限  user:delete:*表示删除所有用户权限  
#user:save 表示用户新增的权限
admin = *
role1 = user:query:*, user:delete:1
[urls]  
# web中的url过滤

maven项目添加依赖

pom.xml

  <!-- shiro的配置-->
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.4.0</version>
    </dependency>
    <dependency>  
        <groupId>commons-logging</groupId>  
        <artifactId>commons-logging</artifactId>  
        <version>1.2</version>  
    </dependency>

测试验证权限

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;

public class TestShiro {
    public static void main(String[] args) {
        //从ini配置文件中读取用户的权限信息  构建SecurityManager对象
        Factory<org.apache.shiro.mgt.SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");  
        org.apache.shiro.mgt.SecurityManager securityManager = (org.apache.shiro.mgt.SecurityManager)factory.getInstance();  
        SecurityUtils.setSecurityManager(securityManager);  
        //获取当前用户
        Subject currentUser = SecurityUtils.getSubject();
        //创建session 当前用户的会话
        Session session = currentUser.getSession();
        session.setAttribute( "保存数据的键", "保存数据的值" );  
       /**    
         * 用户包括两部分   
         * principals and credentials  
         * principals（本人）表示用户的标识信息 比如用户名 用户地址等  
         * credentials（凭证）表示用户用于登录的凭证 比如密码 证书等  
         */  
        //判断是否登录  未登录  才需要登录
        if ( !currentUser.isAuthenticated() ){
            //用户输入的用户名和密码
             UsernamePasswordToken token = new UsernamePasswordToken("admin", "123456");
             //设置记住密码
             token.setRememberMe(true);

             try {
                    currentUser.login( token );
                    System.out.println("登录成功!");
                    System.out.println(currentUser.isAuthenticated());
                    System.out.println(currentUser.isRemembered());
                    //检查登录后的用户是否拥有某个角色
                    if(currentUser.hasRole("role1")){
                        System.out.println("是否拥有role1角色");
                    }
                  //检查登录后的用户是否拥有某个权限
                    if(currentUser.isPermitted("user:delete:1")){
                        System.out.println("是否拥有查询1号的权限");
                    }
                } catch ( UnknownAccountException uae ) {
                    System.out.println("账号错误");

                } catch ( IncorrectCredentialsException ice ) {
                    System.out.println("密码不匹配");

                } catch ( LockedAccountException lae ) {
                    System.out.println("账号被锁定");

                } catch ( AuthenticationException ae ) {
                    System.out.println("位置异常");
                }
        }
    }
}

二。 shiro web
集成web集成参考 http://shiro.apache.org/web.html#programmatic-support
在之前例子基础上进行拓展添加war项目添加shiro-web依赖在pom.xml中

<dependency>
   <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-web</artifactId>
    <version>1.4.0</version>
</dependency>

web.xml添加shiro支持的过滤器和ini文件路径配置参数

<context-param>
    <param-name>shiroConfigLocations</param-name>
    <param-value>/WEB-INF/shiro.ini</param-value>
  </context-param>
  <listener>
    <listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class>
  </listener>
  <filter>
    <filter-name>ShiroFilter</filter-name>
    <filter-class>org.apache.shiro.web.servlet.ShiroFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>ShiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>FORWARD</dispatcher>
    <dispatcher>INCLUDE</dispatcher>
    <dispatcher>ERROR</dispatcher>
  </filter-mapping>

添加几个html和jsp用于测试
login.html添加用于登录的表单
目录结构:
这里写图片描述

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>login.html</title>
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="this is my page">
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
  </head>
  <body>
      <form action="loginServlet" method="post">  
               用户名 :<input type="text" name="userName"/>  
                密码:<input type="text" name="password"/>  
        <input type="submit">  
      </form>  
  </body>
</html>

添加一个检测没有角色失败页面fall.jsp

<body>
    <font color=red size="50px">您没有权限！</font>
</body>

添加一个检测没有角色成功页面suc.jsp

<body>
    <font color=pink size="50px">登录成功！</font>
</body>

添加一个登录的servlet
web.xml

 <servlet>
    <description></description>
    <display-name>LoginServlet</display-name>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.et.servlet.LoginServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/loginServlet</url-pattern>
  </servlet-mapping>

servlet类

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;

public class LoginServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    public LoginServlet() {

    }

    /**  
     * 登录进入方法  
     */  
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String userName=request.getParameter("userName");
        String password=request.getParameter("password");
        //获取当前用户
        Subject currentUser = SecurityUtils.getSubject();
        //用户输入的用户名和密码
         UsernamePasswordToken token = new UsernamePasswordToken("admin", "123456");
         try {
                currentUser.login( token );
                request.getRequestDispatcher("/suc.jsp").forward(request, response);
                //检查登录后的用户是否拥有某个角色
                if(currentUser.hasRole("role1")){
                    System.out.println("是否拥有role1角色");
                }
              //检查登录后的用户是否拥有某个权限
                if(currentUser.isPermitted("user:delete:1")){
                    System.out.println("是否拥有查询1号的权限");
                }
            } catch ( UnknownAccountException uae ) {
                System.out.println("账号错误");

            } catch ( IncorrectCredentialsException ice ) {
                System.out.println("密码不匹配");

            } catch ( LockedAccountException lae ) {
                System.out.println("账号被锁定");

            } catch ( AuthenticationException ae ) {
                System.out.println("位置异常");
            }
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
}

修改shiro.ini添加路径过滤

# =======================  
# Shiro INI configuration  
# =======================
[main]
authc.loginUrl=/login.html
#授权 （认证不通过）【输入用户名和密码】 不通过跳转到loginUrl
roles.loginUrl=/login.html 
#授权 （没有某个角色和权限） 不通过
roles.unauthorizedUrl=/fall.html
#权限 （认证不通过）【输入用户名和密码】 不通过跳转到loginUrl
perms.loginUrl=/login.html 
#权限 （没有某个角色和权限） 不通过
perms.unauthorizedUrl=/fall.html

[users]  
# 设置用户信息  
# 语法是 username = password, roleName1, roleName2, …, roleNameN  
admin = 123456,role1  

[roles]  
# 角色信息和角色拥有的权限  
#语法是 rolename = permissionDefinition1, permissionDefinition2, …, permissionDefinitionN  
#权限的语法 * 表示所有权限  一般语法是 权限类型.权限动作.权限的资源id  比如  user:delete:1 表示拥有删除1号用户的权限  user:delete:*表示删除所有用户权限  
#user:save 表示用户新增的权限
admin = *  
role1 = user:query:*, user:delete:1  

[urls]  
# web中的url过滤  访问这个页面 时要求你登录的账号必须拥有某些权限
#语法是  某个路径  = 怎样过滤1，过滤2   常用的过滤有  
#anon匿名
/login.html = anon
#authc过滤器 认证 表示用户和密码登录过滤 没有登录自动跳转到登录页
/suc.jsp = authc
#授权roles是否拥有某个角色  用法roles[administrator]  
#/suc.jsp = roles[role2]
#指定更细的权限 是否拥有某些权限过滤
#/suc.jsp = perms[user:delete:1]

shiro集成spring

权限涉及到的数据表以及模型关系
这里写图片描述

Apache shiro框架官网地址：http://shiro.apache.org 提供的进行权限控制的方式：

首先来完成一些配置文件，先从pom.xml开始

<dependencies>
      <!-- shiro的配置-->
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.4.0</version>
    </dependency>
    <dependency>  
        <groupId>commons-logging</groupId>  
        <artifactId>commons-logging</artifactId>  
        <version>1.2</version>  
    </dependency>  
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-web</artifactId>
        <version>1.4.0</version>
    </dependency>

    <!-- shiro集成spring的配置 -->
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring</artifactId>
        <version>1.4.0</version>
    </dependency>

    <!-- springmvc的配置-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.2.0.RELEASE</version>
    </dependency>
    <!-- 事务的配置 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>4.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>4.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.2.0.RELEASE</version>
    </dependency>
    <!-- 事务的配置 -->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.12</version>
        </dependency>
    <!-- (druid)连接池的配置 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.5</version>
    </dependency>
    <!-- 文件上传 -->
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.3.3</version>
    </dependency>
    <!-- mybatis集成spring -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.2.3</version>
    </dependency>
      <!-- 配置mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.2.8</version>
    </dependency>
        <!-- 添加jacson的json解析库  -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.6.0</version>
    </dependency>
    <!-- log4j日志配置 -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.5</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-core-asl</artifactId>
      <version>1.9.12</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.6.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.6.0</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.12</version>
    </dependency>
    <!-- mysql的配置 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.26</version>
    </dependency>

    <dependency>
      <groupId>org.apache.openejb</groupId>
      <artifactId>javaee-api</artifactId>
      <version>5.0-1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.faces</groupId>
      <artifactId>jsf-api</artifactId>
      <version>1.2_04</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.faces</groupId>
      <artifactId>jsf-impl</artifactId>
      <version>1.2_04</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

接下来在web.xml中添加Spring监听器、Shiro过滤器和SpringMVC支持：

 <!-- 
    ================================================
        spring配置
    ================================================
   -->
    <!-- spring配置文件位置 -->
     <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
     </context-param>  
     <!-- 配置监听 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>  


      <!--shiro集成spring 配置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>

  <!-- 
    ================================================
        springmvc配置
    ================================================
   -->

    <filter>
        <filter-name>Filter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>Filter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
     <!-- 请求method支持put和delete必须添加过滤器 支持rest风格-->
    <filter>
        <filter-name>myFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>myFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  <!-- springmvc的核心配置 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 指定springmvc的配置文件名称 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/mymvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 启用druid的监控功能 -->
    <servlet>
        <servlet-name>mydruid</servlet-name>
        <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
        <init-param>
            <param-name>loginUsername</param-name>
            <param-value>admin</param-value>
        </init-param>
        <init-param>
            <param-name>loginPassword</param-name>
            <param-value>admin</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>mydruid</servlet-name>
        <url-pattern>/druid/*</url-pattern>
    </servlet-mapping>

spring.xml中配置

<?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:p="http://www.springframework.org/schema/p"
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="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.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
    ">
    <!--spring是bean的容器（service+dao处理） 扫描 -->
    <context:component-scan base-package="com.et">
    <!-- 排除注解 -->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <context:property-placeholder location="classpath:/jdbc.properties" />
    <!-- 所有数据库操作的源头实现子接口DataSource
        DriverManagerDataSource （请求产生一个连接 用完关闭 连接要重用 这样的机制叫连接池）
    -->
    <!-- 数据源只是为了获取连接池-->
    <bean id="dataSource"
        class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${url}"></property>
        <property name="username" value="${username1}"></property>
        <property name="password" value="${password2}"></property>
        <property name="driverClassName" value="${driverClass}"></property>
        <!-- 默认初始化的连接个数 -->
        <property name="initialSize" value="1"></property>
        <!--最大允许的连接个数 -->
        <property name="maxActive" value="200"></property>
        <!-- 最大的等待人数 -->
        <property name="maxIdle" value="100"></property>
        <!-- 监控sql 开启sql统计功能 -->
        <property name="filters" value="stat"></property>
    </bean>
    <!-- 通过spring集成mybatis  -->
    <!-- 配置session工厂 --> 
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入连接的数据源 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <bean id="sessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <!-- 构造器注入工厂 -->
        <constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
    </bean>
    <!-- 扫描mybatis的接口映射 (*..* 任意多层次的包两个以上的包) -->
    <bean id="scannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.*.dao"></property>
    </bean>
    <!-- 事务管理器 -->
    <bean id="tm" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 提交连接事务 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 所有的认证授权 需要securityManager -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="myDbRealm"/> 
    </bean>
    <!-- 后置处理器  负责销毁securityManager-->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

    <!-- shiro集成spring -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <!-- 没有登录的时 跳转到成功的页面-->
        <property name="loginUrl" value="/login.html"/>
        <!-- 授权  没有权限时跳转到该页面 -->
        <property name="unauthorizedUrl" value="/fall.html"/>
        <property name="filterChainDefinitions">
            <value>
                /login.html = anon
                /suc.jsp = roles[role2]
            </value>
        </property>
    </bean>
</beans>

springmvc.xml配置

<?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:p="http://www.springframework.org/schema/p"
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="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.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
    ">
    <!--springmvc控制层处理+视图层 扫描 -->
    <context:component-scan base-package="com.et">
    <!-- 排除注解 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
    </context:component-scan>
    <!--默认的交给spring处理 -->
    <mvc:default-servlet-handler/>
    <!-- 文件上传 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>
    <context:property-placeholder location="classpath:/jdbc.properties" />
    <!-- 引用返回对象 响应json -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <!-- 配置返回字节数组解析成json的消息转换器 -->
            <bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                    <!-- 设置响应支持的类型 -->
                        <value>text/html;charset="UTF-8"</value>
                        <!-- 设置请求body支持的类型 -->
                        <value>application/x-www-form-urlencoded</value>
                    </list>
                </property>
            </bean>
            <!-- 配置返回对象解析成json的消息转换器 -->
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                    <!-- 设置响应支持的类型 -->
                        <value>text/html;charset="UTF-8"</value>
                        <!-- 设置请求body支持的类型 -->
                        <value>application/x-www-form-urlencoded</value>
                    </list>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
</beans>

shiro集成spring例子


/**
 * 自定义realm的实现
 * @author Administrator
 *注入到spring的容器中用注解@Component 会自动装配一个bean bean的名字首字母小写
 */
@Component
public class MyDbRealm extends AuthorizingRealm{
    @Autowired
    UserMapper user;
    /**
     * 认证
     * 将登录输入的用户名和密码和数据库中的用户名和密码对比是否相等
     * 返回值null 表示认证失败 非null认证通过
     * 返回sa表示登录成功
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //获取页面传入的token（用户名和密码）
         UsernamePasswordToken upt= (UsernamePasswordToken)token;
         UserInfo queryUser=user.queryUser(upt.getUsername());

         //判断用户有没有
         if(queryUser!=null && queryUser.getPassword().equals(new String(upt.getPassword()))){

             //创建账号
             SimpleAccount sa=new SimpleAccount(upt.getUsername(),upt.getPassword(),"MyDbRealm");
             return sa;
         }
        return null;
    }

    /**
     * 获取当前用户的授权数据
     * @param arg0
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        /*//获取用户名
        String userName = principals.getPrimaryPrincipal().toString();
        Set<String> roleList=user.queryRoleByName(userName);
        Set<String> permList=user.queryPermByName(userName);
        //创建对象
        SimpleAccount sa=new SimpleAccount();
        sa.setRoles(roleList);
        sa.setStringPermissions(permList);
        return sa;*/
        System.out.println("获取权限信息");
        String userName=principals.getPrimaryPrincipal().toString();
        Set<String> roleList=user.queryRoleByName(userName);
        Set<String> permsList=user.queryPermByName(userName);
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
        authorizationInfo.setRoles(roleList);  
        authorizationInfo.setStringPermissions(permsList);  
        return authorizationInfo;  
    }
}

dao层

public interface UserMapper {

    @Select("select user_name as userName,pass_word as password from user_info where user_name=#{0}")
    public UserInfo queryUser(String userName);

    /**
     * 通过名称查询角色
     * @param userName
     * @return
     */
    @Select("SELECT r.role_name FROM user_info u "
            + "INNER JOIN user_role_relation urr ON u.user_id=urr.user_id "
            + "INNER JOIN role r ON urr.role_id=r.role_id WHERE user_name=#{0}")
    public Set<String> queryRoleByName(String userName);

    /**
     * 通过名称查询角色
     * @param userName
     * @return
     */
    @Select("SELECT p.perm_tag FROM user_info u INNER JOIN user_role_relation urr ON u.user_id=urr.user_id "
                + " INNER JOIN role r ON urr.role_id=r.role_id "
                + " INNER JOIN role_perm_relation rpr ON r.role_id=rpr.role_id "
                + " INNER JOIN perms p ON rpr.perm_id=p.perm_id " 
                + " WHERE user_name=#{0}")
    public Set<String>  queryPermByName(String userName);
}

entity层

public class UserInfo {
    private String userId;
    private String userName;
    private String password;
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

controlloer层

@Controller
public class LoginController {
    @RequestMapping("/loginShiro")
    public String login(String userName,    String password){

        //获取当前用户
        Subject currentUser = SecurityUtils.getSubject();
        //用户输入的用户名和密码
         UsernamePasswordToken token = new UsernamePasswordToken(userName, password);

         try {

                currentUser.login( token );
                return "/suc.jsp";

            } catch ( UnknownAccountException uae ) {
                System.out.println("账号错误");

            } catch ( IncorrectCredentialsException ice ) {
                System.out.println("密码不匹配");

            } catch ( LockedAccountException lae ) {
                System.out.println("账号被锁定");

            } catch ( AuthenticationException ae ) {
                System.out.println("位置异常");
            }
                return "/error.jsp";
    }
}

jdbc .properties

url=jdbc\:mysql\://localhost\:3306/auth
driverClass=com.mysql.jdbc.Driver
username1=root
password2=123456

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>login.html</title>
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="this is my page">
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">

  </head>
  <body>
      <form action="loginShiro" method="post">  
               用户名 :<input type="text" name="userName"/>  
                密码:<input type="text" name="password"/>  
        <input type="submit">  
      </form>  
  </body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <font color=pink size="50px">登录成功！</font>
</body>
</html>

自定义filter实现动态配置url拦截

自定义过滤器的代码是注意添加到spring容器中添加@Component注解

import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.CollectionUtils;
import org.apache.shiro.web.filter.authz.AuthorizationFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.et.shiro.dao.UserMapper;
import com.et.shiro.entity.Menu;


@Component  
public class MyFilter extends AuthorizationFilter {  

    @Autowired  
    private ShiroFilterFactoryBean sffb;  
    /**  
     * 匹配指定过滤器规则的url  
     * @param regex  
     * @param url  
     * @return  
     */  
    public static boolean matchUrl(String regex,String url){  
        regex=regex.replaceAll("/+", "/");  
        if(regex.equals(url)){  
            return true;  
        }  
        regex=regex.replaceAll("\\.", "\\\\.");  
        // /login.html  /l*.html  
        regex=regex.replaceAll("\\*", ".*");  
        // /**/login.html  /a/b/login.html  
        if(regex.indexOf("/.*.*/")>=0){  
            regex=regex.replaceAll("/\\.\\*\\.\\*/", "((/.*/)+|/)");  
        }  
        System.out.println(regex+"----"+url);  
        return Pattern.matches(regex, url);  
    } 
    @Autowired
    UserMapper user;
    /**  
     * 测试  
     * @param args  
     */  
    public static void main(String[] args) {  
        System.out.println(matchUrl("/**/s*.html","/t/g/login.html"));  
    }  

    /**  
     * isAccessAllowed用于判断当前url的请求是否能验证通过  如果验证失败 调用父类的onAccessDenied决定跳转到登录失败页还是授权失败页面  
     */  
    @Override  
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)  
            throws Exception {
        HttpServletRequest req=(HttpServletRequest)request;
        String contextPath=req.getContextPath();
        //获取用户访问的资源的路径
        String url=req.getRequestURI();
        url=url.split(contextPath)[1];
        //通过url获取需要那些认证  
        //List<Menu> queryMenu=user.queryByUrl(url);
        List<Menu> queryMenu=user.queryMenu();
      //数据库没有配置当前url的授权
        if(queryMenu.size()==0){
            return false;
        }

        String urlAuth=null;
        for(Menu menu:queryMenu){
            if(matchUrl(menu.getMenuUrl(),url)){
                //获取权限
                urlAuth=menu.getMenuFilter();
            }
        }

        if(urlAuth==null){  
            return false;  
        }  
        //配置的过滤器是anon 直接放过  
        if(urlAuth.startsWith("anon")){  
            return true;  
        }  
        //配置的是authc 判断当前用户是否认证通过  
        Subject subject = getSubject(request, response);  
        if(urlAuth.startsWith("authc")){  
            return subject.isAuthenticated();  
        }  
        //授权认证 也需要判断是否登录 没有登录返回 登录继续下面的验证  
        boolean ifAuthc=subject.isAuthenticated();  
        if(!ifAuthc)  
            return ifAuthc;  
        //如果是定义的roles过滤器  获取所有的roles 一般是roles[a,b]  
        if(urlAuth.startsWith("roles")){  
            String[] rolesArray=urlAuth.split("roles\\[")[1].split("\\]")[0].split(",");  
            if (rolesArray == null || rolesArray.length == 0) {  
                return true;  
            }  
            Set<String> roles = CollectionUtils.asSet(rolesArray);  
            return subject.hasAllRoles(roles);  
        }  
        if(urlAuth.startsWith("perms")){  
            String[] perms=urlAuth.split("perms\\[")[1].split("\\]")[0].split(",");  
            boolean isPermitted = true;  
            if (perms != null && perms.length > 0) {  
                if (perms.length == 1) {  
                    if (!subject.isPermitted(perms[0])) {  
                        isPermitted = false;  
                    }  
                } else {  
                    if (!subject.isPermittedAll(perms)) {  
                        isPermitted = false;  
                    }  
                }  
            }  
            return isPermitted;  
        }  
        return false;  
    }  
}

修改springboot的Config类将所有的请求都交给自定义的过滤器处理

@Bean  
    public ShiroFilterFactoryBean shiroFilter(@Autowired org.apache.shiro.mgt.SecurityManager securityManager){  
        ShiroFilterFactoryBean sffb=new ShiroFilterFactoryBean();  
        sffb.setSecurityManager(securityManager);  
        sffb.setLoginUrl("/login.html");  
        sffb.setUnauthorizedUrl("/un.jsp");  
        Map<String, String> urls=new HashMap<String, String>();  
        urls.put("/**", "myFilter");          
        sffb.setFilterChainDefinitionMap(urls);  
        return sffb;  
    }

spring.xml


    <!-- shiro集成spring -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <!-- 没有登录的时 跳转到成功的页面-->
        <property name="loginUrl" value="/login.html"/>
        <!-- 授权  没有权限时跳转到该页面 -->
        <property name="unauthorizedUrl" value="/fall.html"/>
        <property name="filters">
            <util:map>
                <entry key="authc" value-ref="myFilter"></entry>
            </util:map>
        </property>
        <property name="filterChainDefinitions">
            <value>
            <!-- 引用MyFilter类首字母小写 -->
                /** = authc
            </value>
        </property>
    </bean>

所有的权限都要配置在数据库中
这里写图片描述

public class Menu {
    private String menuId;
    private String menuName;
    private String menuUrl;
    private String menuFilter;
    private String isMenu;
    public String getMenuId() {
        return menuId;
    }
    public void setMenuId(String menuId) {
        this.menuId = menuId;
    }

    public String getMenuName() {
        return menuName;
    }
    public void setMenuName(String menuName) {
        this.menuName = menuName;
    }

    public String getMenuUrl() {
        return menuUrl;
    }
    public void setMenuUrl(String menuUrl) {
        this.menuUrl = menuUrl;
    }
    public String getMenuFilter() {
        return menuFilter;
    }
    public void setMenuFilter(String menuFilter) {
        this.menuFilter = menuFilter;
    }
    public String getIsMenu() {
        return isMenu;
    }
    public void setIsMenu(String isMenu) {
        this.isMenu = isMenu;
    }
}


@Controller
public class EmpController {
    @Autowired
    EmpService  service;
    /**
     * 查询的方法
     */
    @ResponseBody
    @RequestMapping("/queryEmp")
    public PageTools queryEmp(Integer id,String ename,Integer page,Integer rows){

        return service.queryEmp(id,ename, page, rows);
    }

    /**
     * 修改员工信息
     */
    @ResponseBody
    @RequestMapping(value="/updateEmp/{id}",method=RequestMethod.PUT)
    public Result updateEmp(@PathVariable Integer id,Emp emp,Integer page,Integer rows){
        emp.setId(id);
        Result rt=new Result();
        rt.setCode(1);
        try {
            service.updateEmp(emp);
        } catch (Exception e) {
            rt.setCode(0);
            rt.setMessage(e);
        }
        return rt;
    }
    /**
     *添加员工信息
     */
    @ResponseBody
    @RequestMapping(value="/saveEmp",method=RequestMethod.POST)
    public Result saveEmp(Emp emp){
        Result rt=new Result();
        rt.setCode(1);
        try {

            service.saveEmp(emp);
        } catch (Exception e) {
            rt.setCode(0);
            rt.setMessage(e);
        }
        return rt;
    }

    /**
     * 删除学生
     */
    @ResponseBody
    @RequestMapping(value="/deleteEmp/{id}",method=RequestMethod.DELETE)
    public Result deleteEmp(@PathVariable String id,Integer page,Integer rows){
        //删除一行
        Result rt=new Result();
        rt.setCode(1);
        try {
            //检测异常
            //String str=null;
            //str.toString();
            service.deleteEmp(Integer.parseInt(id));
        } catch (Exception e) {
            rt.setCode(0);
            rt.setMessage(e);
        }
        return rt;
    }   
}