架构之路之spring+shiro的集成

1.前言

1.1 shiro介绍

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

1.2使用api

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能得到合法的用户及其权限进行判断。

2.集成项目

2.1 依赖

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

2.2 shiro-context.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <!--自定义权限认证-->
    <bean id="authRealm" class="com.tl.skyLine.shiro.AuthRealm">
        <!--自定义密码加密算法  -->
        <!--<property name="credentialsMatcher" ref="passwordMatcher"/>-->
        <!--<property name="roleDao" ref="roleDao"/>-->
        <!--<property name="permissionDao" ref="permissionDao"/>-->
    </bean>

    <!-- 设置密码加密策略 md5hash -->
    <!--<bean id="passwordMatcher" class="com.fyh.www.shiro.CustomCredentialsMatcher"/>-->

    <!-- 配置权限管理器(核心) -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <!-- 我们自定义的realm -->
        <property name="realm" ref="authRealm"/>
        <!-- 缓存管理器 -->
        <property name="cacheManager" ref="cacheManager"/>
    </bean>

    <!-- 此bean要被web.xml引用,和web.shiroFilter -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <!-- 权限管理器 -->
        <property name="securityManager" ref="securityManager"/>
        <!-- 登录地址 -->
        <property name="loginUrl" value="/pages/login.jsp"/>
        <!-- 登录后跳转到业务页面 -->
        <property name="successUrl" value="/pages/home.jsp"/>
        <!-- 错误页面 -->
        <property name="unauthorizedUrl" value="/pages/unauthorized.jsp"/>
        <!-- 权限配置 -->
        <property name="filterChainDefinitions">
            <value>
                <!-- 匿名登录请求 -->
                /public/** = anon
                <!-- **代表任意子目录 -->
                /static/**=anon
                <!-- 需要权限为edit的用户才能访问此请求-->
                /user/edit=perms[user:edit]
                <!-- 需要管理员角色才能访问此页面 -->
                <!--/user/edit=roles[admin]-->
                <!--拦截非静态资源的所有请求-->
                /** = authc
                <!--authc:确保已认证的用户发送的请求才能通过（若未认证，则跳转到登录页面）-->
            </value>
        </property>
    </bean>

    <!-- 用户授权/认证信息Cache, 采用EhCache  缓存 -->
    <!--<bean id="shiroEhcacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">-->
    <!--<property name="cacheManagerConfigFile" value="classpath:ehcache-shiro.xml"/>-->
    <!--</bean>-->

    <bean id="cacheManager" class="org.apache.shiro.cache.MemoryConstrainedCacheManager"/>
    <!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

    <!-- 安全管理器 -->
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    <!--启用Shiro相关的注解-->
    <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>
</beans>

2.3 导入spring-context.xml和springmvc-context.xml中

<import resource="shiro-context.xml"/>

这边对之前的配置要做一些修改，涉及到spring父子容器的查看范围的问题，参考下一篇文章

点击打开链接

修改的spring-context.xml：

 <context:component-scan base-package="com.tl.skyLine">
        <!-- 排除不扫描的,controller放在子容器springmvc的配置文件中 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

修改的springmvc-context.xml：

<!--只在springmvc容器中配置controller的扫描-->
    <context:component-scan base-package="com.tl.skyLine" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

2.4 web.xml

<filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

这个shiroFilter与shiro-context.xml中的<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">对应。

2.5 自定义AuthRealm

package com.tl.skyLine.shiro;

import com.tl.skyLine.model.User;
import com.tl.skyLine.repository.PermissionDao;
import com.tl.skyLine.repository.RoleDao;
import com.tl.skyLine.repository.UserDao;
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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.stream.Collectors;

/**
 * Created by tl on 17/2/20.
 */
@Component
public class AuthRealm extends AuthorizingRealm {

    @Autowired
    private RoleDao roleDao;

    @Autowired
    private PermissionDao permissionDao;

    @Autowired
    private UserDao userDao;

    /**
     * 用来为当前登陆成功的用户授予权限和角色（已经登陆成功了）
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(
            PrincipalCollection principals) {
        //获取用户名
        //String username = (String) principals.getPrimaryPrincipal();
        //获取当前用户
        User user = (User) principals.fromRealm(getName()).iterator().next();
        //得到权限字符串
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

        info.addRoles(roleDao.getRoles(user.getId())
                .stream().map(role -> role.getName()).collect(Collectors.toList()));
        info.addStringPermissions(permissionDao.getPermissionByUser(user.getId())
                .stream().map(permission -> permission.getName()).collect(Collectors.toList()));
        return info;
    }

    /**
     * 用来验证当前登录的用户，获取认证信息
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken authcToken) throws AuthenticationException {
        UsernamePasswordToken upToken = (UsernamePasswordToken) authcToken;

        User user = userDao.findOneByUsername(upToken.getUsername());
        if (user == null) {
            return null;
        } else {
            AuthenticationInfo info = new SimpleAuthenticationInfo(user, user.getPassword(), getName());
            return info;
        }
    }

}

在认证、授权内部实现机制中都有提到，最终处理都将交给Realm进行处理。 因为在Shiro中，最终是通过Realm来获取应用程序中的用户、角色及权限信息的。通常情况下，在Realm中会直接从我们的数据源中获取Shiro需要的验证信息。 可以说，Realm是专用于安全框架的DAO.

shiro登陆成功，再次访问url的时候会请求doGetAuthorizationInfo时候会将登陆用户对应的角色，权限全部查到，然后set到SimpleAuthorizationInfo实例对象info中，保存的分别是role和permission对象的name字段，

这个name子段跟shiro-context.xml中的shiroFilterbean对象的filterChainDefinitions属性对应：

2.6 角色权限类的结构

我这边是用mongodb数据库，没有外键关联约束，就是基本的用户，角色，权限，然后外加两个中间表，我就不一一贴出了。

2.7 repository

由于非关系数据库的约束性，这边做表关联查询没有关系型数据库那么简单，这个对整体框架没有影响，我把这个代码贴一下：

RoleDaoImpl:

package com.tl.skyLine.repository.impl;

import com.tl.skyLine.model.Role;
import com.tl.skyLine.model.UserRole;
import com.tl.skyLine.repository.RoleDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * RoleDaoImpl
 * Created by tl on 17/2/13.
 */
@Component("roleDao")
public class RoleDaoImpl implements RoleDao {

    @Autowired
    private MongoTemplate mongoTemplate;


    @Override
    public Role findOne(String roleId) {
        return this.mongoTemplate.findOne(new Query().addCriteria(Criteria.where("id").is(roleId)), Role.class);
    }

    @Override
    public List<Role> getRoles(String userId) {
        Query query = new Query();
        query.addCriteria(Criteria.where("userId").is(userId));
        List<UserRole> userRoles = this.mongoTemplate.find(query, UserRole.class);
        List<Role> roles = new ArrayList<Role>();
        userRoles.stream().forEach(userRole -> {
            roles.add(this.findOne(userRole.getRoleId()));
        });
        return roles;
    }

    @Override
    public void store(Role role) {
        this.mongoTemplate.save(role);
    }

    @Override
    public void store(UserRole userRole) {
        this.mongoTemplate.save(userRole);
    }

    @Override
    public Role findOneByName(String name) {
        return this.mongoTemplate.findOne(
                new Query().addCriteria(Criteria.where("name").is(name))
                , Role.class);
    }
}

PermissionImpl:

package com.tl.skyLine.repository.impl;

import com.tl.skyLine.model.Permission;
import com.tl.skyLine.model.RolePermission;
import com.tl.skyLine.repository.PermissionDao;
import com.tl.skyLine.repository.RoleDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * PermissionDaoImpl
 * Created by tl on 17/2/13.
 */
@Component("permissionDao")
public class PermissionDaoImpl implements PermissionDao {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private RoleDao roleDao;


    @Override
    public Permission findOne(String permissionId) {
        return this.mongoTemplate.findOne(new Query().addCriteria(Criteria.where("id").is(permissionId)), Permission.class);
    }


    @Override
    public List<Permission> getPermissionByRole(String roleId) {
        Query query = new Query();
        query.addCriteria(Criteria.where("roleId").is(roleId));
        List<RolePermission> rolePermissions = this.mongoTemplate.find(query, RolePermission.class);
        List<Permission> permissions = new ArrayList<Permission>();
        rolePermissions.stream().forEach(rolePermission -> {
            permissions.add(this.findOne(rolePermission.getPermissionId()));
        });
        return permissions;
    }

    @Override
    public List<Permission> getPermissionByUser(String userId) {
        List<Permission> permissions = new ArrayList<Permission>();
        roleDao.getRoles(userId).stream().forEach(role -> {
            permissions.addAll(this.getPermissionByRole(role.getId()));
        });
        return permissions;
    }

    @Override
    public void store(Permission permission) {
        this.mongoTemplate.save(permission);
    }

    @Override
    public void store(RolePermission rolePermission) {
        this.mongoTemplate.save(rolePermission);
    }

    @Override
    public Permission findOneByName(String name) {
        return this.mongoTemplate.findOne(
                new Query().addCriteria(Criteria.where("name").is(name))
                , Permission.class);
    }
}

2.8 单元测试增加测试数据

    /**
     * 关联用户角色权限
     */
    @Test
    public void testShiro() {
        Role role = new Role();
        role.setName("admin");
        role.setDescription("管理员权限");
        roleDao.store(role);

        UserRole userRole = new UserRole();
        userRole.setRoleId(role.getId());
        userRole.setUserId(userDao.findOneByUsername("admin").getId());

        roleDao.store(userRole);

        Permission permission = new Permission();
        permission.setName("edit");
        permission.setDescription("编辑权限");
        permissionDao.store(permission);

        RolePermission rolePermission = new RolePermission();
        rolePermission.setRoleId(role.getId());
        rolePermission.setPermissionId(permission.getId());

        permissionDao.store(rolePermission);
    }

2.9 controller类和jsp

PublicController：

/**
 * PublicController
 * Created by tl on 17/2/13.
 */
@Controller
@RequestMapping("/public")
public class PublicController {

    @Autowired
    private UserDao userDao;


    //用户登录
    @RequestMapping("/login")
    public String login(User user, HttpServletRequest request) {
        Subject subject = SecurityUtils.getSubject();
        userDao.findAll();
        UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(), user.getPassword());
        try {
            subject.login(token);//会跳到我们自定义的realm中
            request.getSession().setAttribute("user", user);
            return "success";
        } catch (Exception e) {
            e.printStackTrace();
            request.getSession().setAttribute("user", user);
            request.setAttribute("error", "用户名或密码错误！");
            return "login";
        }
    }

    @RequestMapping("/logout")
    public String logout(HttpServletRequest request) {
        request.getSession().invalidate();
        return "index";
    }

}

login.jsp

<!DOCTYPE html>
<%@ page language="java" contentType="text/html; charset=GB2312" %>
<html lang="en">
<head>
    <title>登录页面</title>
</head>
<body>
<%
    String path = request.getContextPath();
// 获得项目完全路径（假设你的项目叫skyLine，那么获得到的地址就是http://localhost:8080/skyLine/）:
    String basePath = request.getScheme() + "://"
            + request.getServerName() + ":" + request.getServerPort()
            + path + "/";
%>

<form action="${basePath}/public/login" method="post">
    <span>用户名:</span><input type="text" name="username"/><br>
    <span>密码:</span><input type="password" name="password"/><br>
    <input type="submit" value="登陆">${error}
</form>


</body>
</html>

success.jsp

<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<!DOCTYPE html>
<%@ page language="java" contentType="text/html; charset=GB2312" %>
<html lang="en">
<head>
    <title>success</title>
</head>
<body>

<p>登陆成功!欢迎你${user.username}</p>
<a href="${pageContext.request.contextPath}/user/list">进入用户list页面</a>

<shiro:hasPermission name="user:edit">
    <p>你有权限看到此处!</p>
</shiro:hasPermission>
</body>
</html>

上面的<shiro:hasPermission name="user:edit">注解，下节再讲

点击打开链接

3.开始测试shiro权限

     首先项目启动之后，不再运行web.xml这行代码<welcome-file-list>，而是直接被shiroFilter过滤，执行shiro-context.xml配置文件中的<property name="loginUrl" value="/pages/login.jsp"/>，进入登录页面，然后输入登录信息，进入publicController中的login方法，执行到subject.login(token);时会跳转到我们自定义的realm中进行用户名和密码校验，成功跳转success.jsp，失败重新返回login.jsp页面，同时显示报错信息！

    下面针对shiro-contex.xml中的url设置，访问http://localhost:8080/user/edit，提示访问成功，如果将配置文件的/user/edit=perms[user:edit]中的use:edit改成use:edit，重新启动，再次访问则会报错，提示没有访问权限

   但是，上面的配置有一个局限性，就是每次在配置文件里面加url权限，会很麻烦，每次都要重启，而且shiro权限是细粒化的这种加配置的方法会产生很多代码，是有意下文我们将介绍通过注解在controller和jsp中如何实现权限细粒化！