SSM集成安全框架shiro

最新推荐文章于 2021-09-02 16:33:58 发布

艳学网

最新推荐文章于 2021-09-02 16:33:58 发布

阅读量2.5k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： java工具文章标签：安全框架 shiro 管理博客

本文链接：https://blog.youkuaiyun.com/sinat_15153911/article/details/78506195

java工具专栏收录该内容

65 篇文章

订阅专栏

SSM集成安全框架shiro
这里写图片描述
前言，阅读这篇博客前可以先看看RBAC打造通用的权限管理平台http://blog.youkuaiyun.com/sinat_15153911/article/details/55046741
之前小编一直用拦截器来实现权限登录的拦截，现在使用高大上的shiro，多重拦截，大量拦截，其中一个安全知识点是md5颜值加密，噢，是盐值。现在就一步一步教大家怎么配置。
也可以加Q490647751，回复‘开通VIP获取SSM集成安全框架shiro’，获取源码研究，当然你还可以使用shiro二级缓存ehcache或者redis缓存session。

视频教程：链接：http://pan.baidu.com/s/1geQJCH1 密码：mo22

第一步导入jar包
shir-core-1.2.3.jar
shiro-ehcache-1.2.3.jar
shiro-spring-1.2.3.jar
shiro-web-1.2.3.jar

第二步配置web.xml

<!-- shiro的filter -->
    <!-- shiro过虑器，DelegatingFilterProxy通过代理模式将spring容器中的bean和filter关联起来 -->
    <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>
        <init-param>
            <param-name>targetBeanName</param-name>
            <param-value>shiroFilter</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

第三步加配置文件applicationContext-shiro.xml

<import resource="applicationContext-*.xml"/>

<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"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.2.xsd 
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">

<!-- web.xml中shiro的filter对应的bean -->
<!-- Shiro 的Web过滤器 -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />
        <!-- loginUrl认证提交地址，如果没有认证将会请求此地址进行认证，请求此地址将由formAuthenticationFilter进行表单认证 -->
        <property name="loginUrl" value="/manage/login.html" />
        <!-- 认证成功统一跳转到index.html，建议不配置，shiro认证成功自动到上一个请求路径 -->
        <property name="successUrl" value="/manage/index.html"/>
        <!-- 通过unauthorizedUrl指定没有权限操作时跳转页面-->
        <property name="unauthorizedUrl" value="/manage/refuse.html" />
        <!-- 自定义filter配置 -->
        <!-- <property name="filters">
            <map>
                将自定义 的FormAuthenticationFilter注入shiroFilter中
                <entry key="authc" value-ref="formAuthenticationFilter" />
            </map>
        </property> -->

        <!-- 过虑器链定义，从上向下顺序执行，一般将/**放在最下边 -->
        <property name="filterChainDefinitions">
            <value>
                <!-- 对静态资源设置匿名访问 -->
                /resource/** = anon
                /file/** = anon
                <!-- 验证码，可匿名访问 -->
                /validatecode.jsp = anon

                <!-- 请求 logout.action地址，shiro去清除session-->
                /logout.html = logout
                <!--商品查询需要商品查询权限 ，取消url拦截配置，使用注解授权方式 -->
                <!-- /items/queryItems.action = perms[item:query]
                /items/editItems.action = perms[item:edit] -->
                <!-- 配置记住我或认证通过可以访问的地址 -->
                /login.jsp  = user
                /index.html = user
                /welcome.jsp = user 
                <!-- /** = authc 所有url都必须认证通过才可以访问-->
                /** = authc
                <!-- /** = anon所有url都可以匿名访问 -->

            </value>
        </property>
    </bean>

<!-- securityManager安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="customRealm" />
        <!-- 注入缓存管理器 -->
        <!-- <property name="cacheManager" ref="cacheManager"/>  -->
        <!-- 注入session管理器 -->
        <property name="sessionManager" ref="sessionManager" /> 
        <!-- 记住我 -->
        <property name="rememberMeManager" ref="rememberMeManager"/> 

    </bean>

<!-- realm -->
<bean id="customRealm" class="com.yanhui.shiro.CustomRealm">
<!-- 将凭证匹配器设置到realm中，realm按照凭证匹配器的要求进行散列 -->
    <property name="credentialsMatcher" ref="credentialsMatcher"/> 
</bean>

<!-- 凭证匹配器 -->
<bean id="credentialsMatcher"
    class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
    <property name="hashAlgorithmName" value="md5" />
    <property name="hashIterations" value="1" />
</bean> 

<!-- 缓存管理器 -->
<!-- <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
    <property name="cacheManagerConfigFile" value="classpath:shiro-ehcache.xml"/>
</bean> -->

<!-- 会话管理器 -->
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
    <!-- session的失效时长，单位毫秒 -->
    <property name="globalSessionTimeout" value="600000"/>
    <!-- 删除失效的session -->
    <property name="deleteInvalidSessions" value="true"/>
</bean>

<!-- rememberMeManager管理器 -->
<bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
    <property name="cookie" ref="rememberMeCookie" />
</bean>
<!-- 记住我cookie -->
<bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
    <constructor-arg value="rememberMe" />
    <!-- 记住我cookie生效时间30天 -->
    <property name="maxAge" value="2592000" />
</bean>



</beans>

第四步添加CustomRealm的类

package com.yanhui.shiro;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;

import com.yanhui.mapping.system.UserManagerMapper;
import com.yanhui.pojo.auth.Permission;
import com.yanhui.pojo.system.UserManager;
import com.yanhui.service.auth.PermissionService;


public class CustomRealm extends AuthorizingRealm {

    public static void main(String[] args) {
        //所需加密的参数  即  密码
        String source = "123456";
        //[盐] 一般为用户名 或 随机数
        String salt = "customRealm";
        //加密次数
        int hashIterations = 1;

        //调用 org.apache.shiro.crypto.hash.Md5Hash.Md5Hash(Object source, Object salt, int hashIterations)构造方法实现MD5盐值加密
        Md5Hash mh = new Md5Hash(source, salt, hashIterations);
        //打印最终结果
        System.out.println(mh.toString());


        /*调用org.apache.shiro.crypto.hash.SimpleHash.SimpleHash(String algorithmName, Object source, Object salt, int hashIterations)
         * 构造方法实现盐值加密  String algorithmName 为加密算法 支持md5 base64 等*/
        SimpleHash sh = new SimpleHash("md5", source, salt, hashIterations);
        //打印最终结果
        System.out.println(sh.toString());
    }

    @Autowired
    private UserManagerMapper userMapper;

    @Autowired
    private PermissionService permissionService;

    @Override
    public String getName() {
        return "customRealm";
    }

    // 支持什么类型的token
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof UsernamePasswordToken;
    }

    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken token) throws AuthenticationException {

        // 从token中 获取用户身份信息
        String username = (String) token.getPrincipal();
        // 拿username从数据库中查询
//      UserExample example = new UserExample();
//      Criteria criteria = example.createCriteria();
//      criteria.andNameEqualTo(username);
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("name", username);
        List<UserManager> list = userMapper.listForPage(map);
        if(list.size() < 1){
            // 如果查询不到则返回null
            return null;
        }

        UserManager user = list.get(0);
        // 获取从数据库查询出来的用户密码
        String password = user.getPassword();
//      String salt = user.getSalt();
//      String password = "cb571f7bd7a6f73ab004a70322b963d5";
        String salt = "customRealm";

        // 如果查询到返回认证信息AuthenticationInfo

        //activeUser就是用户身份信息
        UserManager activeUser = new UserManager();
        activeUser.setId(user.getId());
//      activeUser.setUsercode(user.getPhone());
        activeUser.setUsername(user.getUsername());
        // 返回认证信息由父类AuthenticatingRealm进行认证
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(
//              employee.getPhone(), "123456", ByteSource.Util.bytes(salt), this.getName());
                user, password, ByteSource.Util.bytes(salt), getName());


        return simpleAuthenticationInfo;
    }


    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(
            PrincipalCollection principals) {

        //身份信息
        UserManager activeUser = (UserManager) principals.getPrimaryPrincipal();
//      Employee activeUser = (Employee) subject.getPrincipal();
        //用户id
        Integer userid = activeUser.getId();
        //获取用户权限
        List<Permission> permissions = null;
        try {
            permissions = permissionService.findPermissionList(userid);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //构建shiro授权信息
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for(Permission permission : permissions){
            simpleAuthorizationInfo.addStringPermission(permission.getPercode());
        }

        return simpleAuthorizationInfo;
    }

        //清除缓存
        public void clearCached() {
            PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();
            super.clearCache(principals);
        }



}

第五步登录方法

/**
     * 后台管理主页
     * @return
     */
    @RequestMapping("/index")
    public String indexAdmin(HttpServletRequest request){
        //主体
        Subject subject = SecurityUtils.getSubject();
//      //身份
        UserManager activeUser = (UserManager) subject.getPrincipal();
        request.setAttribute("activeUser", activeUser);
        HttpSession session = request.getSession(); 
        session.setAttribute(Global.USER_BACKEND_SESSION, activeUser);

        request.setAttribute("mainPage", "welcome.html");
        return Global.WEB_BACK_PAGE + "/index";
    }

/**
     * 后台登录
     * @return
     * @throws Exception 
     */
    @RequestMapping("/login")
    public String login(String username,String password,HttpServletRequest request) throws Exception{
        //如果登陆失败从request中获取认证异常信息，shiroLoginFailure就是shiro异常类的全限定名
                String exceptionClassName = (String) request.getAttribute("shiroLoginFailure");
                //根据shiro返回的异常类路径判断，抛出指定异常信息
                if(exceptionClassName!=null){
                    if (UnknownAccountException.class.getName().equals(exceptionClassName)) {
                        //最终会抛给异常处理器
                        //throw new CustomException("账号不存在");
                        System.out.println("账号不存在");
                    } else if (IncorrectCredentialsException.class.getName().equals(exceptionClassName)) {
                        //throw new CustomException("用户名/密码错误");
                        System.out.println("用户名/密码错误");
                    } /*else if("randomCodeError".equals(exceptionClassName)){
                        //throw new CustomException("验证码错误 ");
                    }*/else {
                        System.out.println("未知错误");
                        throw new Exception();//最终在异常处理器生成未知错误
                    }
                }

//      String result = "";
//      UserManager user = userService.login(username,password);
//      if(user != null){
//          HttpSession session = request.getSession(); 
//          session.setAttribute(Global.USER_BACKEND_SESSION, user);
//          result = "redirect:/manage/index.html";
//      }else{
//          result = "redirect:/manage/toSignIn.html";
//      }
//      return result;
        return Global.WEB_BACK_PAGE + "/signin";
    }

第六步前端显示

<%@ taglib uri="http://shiro.apache.org/tags" prefix="shiro" %>

<shiro:hasPermission name="dic:query">
        <a href="http://www.baidu.com" class="list-title">dic列表</a>
        </shiro:hasPermission>

知识点：
1、自定义Realm

自定义Realm一般需要实现AuthorizingRealm接口，该接口有两个接口，一个是doGetAuthorizationInfo，另一个是doGetAuthenticationInfo。
doGetAuthenticationInfo（认证）
该接口方法的逻辑是验证用户登录的合法性，通常在这里面来判断用户名是否存在、密码是否正确、用户账号状态是否被禁用或者锁定等操作。
doGetAuthorizationInfo（授权）
该接口方法的逻辑是在用户身份验证完成后，设置用户的权限信息，一般包括设置用户所拥有的角色信息和相应的权限字信息。

2、MD5盐值加密

 int temp;
            temp = ss < 0 ? ss + 256 : ss;
            return GOAL[temp / 16] + GOAL[temp % 16];       //自己实现转化
            /*
                用现有的方法实现转化
                StringBuffer s = new StringBuffer();
                if(temp < 16)s.append("0");
                s.append(Integer.toHexString(temp));
                return s.toString();   
             */

String password_md5_sale_1 = new Md5Hash("123456", "customRealm", 1).toString();

<!-- 凭证匹配器 -->
<bean id="credentialsMatcher"
    class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
    <property name="hashAlgorithmName" value="md5" />
    <property name="hashIterations" value="1" />
</bean>