han_shiro

最新推荐文章于 2024-06-27 18:43:53 发布
置顶 最新推荐文章于 2024-06-27 18:43:53 发布
阅读量359 收藏
点赞数
分类专栏： 后端框架 文章标签： shiro spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43616155/article/details/105988885
版权

shiro

shiro框架能做什么

  • 认证：验证用户身份
  • 授权：对用户执行访问控制：判断用户是否被允许做某事
  • 会话管理：在任何环境下使用Session API，即使没有web
  • 加密：以前简洁 易用的方式使用加密功能，保护或隐藏数据防止被偷窥
  • Realms：聚集一个或者多个用户安全数据的数据源
  • 单点登录

shiro的四大核心部分

  • Authentication：身份验证
  • Authorization:授权，指访问过程中决定是否有权限去访问受保护的资源
  • Session Management：会话管理，管理用户特定的会话
  • Cryptography：加密

shiro的三个核心组件

  • Subject：正在与系统交互的用户，或者某个第三方服务。所有Subject实例都被绑定到SecurityManager上
  • SecurityManager：Shiro架构的心脏协调内部各个安全组件，管理内部组件实例，并通过它来提供安全管理的各种服务。当shiro与一个subject进行交互时，实质上是securitymanager处理所有繁重的的subject安全操作。

在ssm框架中

  • pom文件有关依赖
		<dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.3.2</version>
        </dependency>
  • web.xml中有关配置信息
<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-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
	
</filter>
  • 与spring整合xml
<!-- 配置 Bean 后置处理器: 会自动的调用和 Spring 整合后各个组件的生命周期方法. -->
<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>

<!-- 包含shiro的配置文件 -->
          <import resource="classpath:applicationContext-shiro.xml"/>
  • shiro本身的xml(若按照上一步则该文件名为：applicationContext-shiro.xml)
<!-- 配置緩存管理器 -->
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <!-- 指定 ehcache 的配置文件，下面会给到 -->
        <property name="cacheManagerConfigFile" value="classpath:ehcache-shiro.xml"/>
    </bean>
    
<!-- Realm 的配置（自己创建的类）  init-methood是初始化的方法-->
    <bean id="userAuthorizingRealm" class="com.ken.wms.security.realms.UserAuthorizingRealm" init-method="setCredentialMatcher"/>
 <!-- 认证器 -->  
    <bean id="authenticator" class="org.apache.shiro.authc.pam.ModularRealmAuthenticator">
        <property name="authenticationStrategy">
            <bean class="org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy"/>
        </property>
    </bean>
<!-- 配置 Shiro 的 SecurityManager Bean. -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="cacheManager" ref="cacheManager"/>
        <property name="authenticator" ref="authenticator"/>
        <property name="realms">
            <list>
                <ref bean="userAuthorizingRealm"/>
            </list>
        </property>
    </bean>
      
 <!-- 配置 ShiroFilter bean: 该 bean 的 id 必须和 web.xml 文件中配置的 shiro filter 的 name 一致  -->   
 	<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
 		 <!-- 装配 securityManager -->
        <property name="securityManager" ref="securityManager"/>
         <!-- 配置登陆页面 -->
        <property name="loginUrl" value="/index.jsp"/>
        <!-- 登陆成功后的一面 -->
        <property name="successUrl" value="/shiro-success.jsp"/>
        <!--用户访问无权限的链接时跳转此页面 -->
        <property name="unauthorizedUrl" value="/shiro-unauthorized.jsp"/>
        <property name="filters">
            <util:map>
                <entry key="roles" value-ref="anyOfRoles"/>
                <entry key="authc" value-ref="extendFormAuthenticationFilter"/>
            </util:map>
        </property>
        <!-- 具体配置需要拦截哪些 URL, 以及访问对应的 URL 时使用 Shiro 的什么 Filter 进行拦截.  -->
        <property name="filterChainDefinitionMap" ref="filterChainDefinitionMap"/>
    </bean>
     <!-- 配置身份验证器，处理 Ajax 请求 -->
    <bean id="extendFormAuthenticationFilter" class="com.ken.wms.security.filter.ExtendFormAuthenticationFilter">
        <property name="usernameParam" value="username"/>
        <property name="passwordParam" value="password"/>
        <property name="rememberMeParam" value="rememberMe"/>
        <property name="loginUrl" value="/login"/>
    </bean>
    <bean id="anyOfRoles" class="com.ken.wms.security.filter.AnyOfRolesAuthorizationFilter"/>
     <!-- 配置获取 URL 权限信息的 Factory -->
    <bean id="filterChainDefinitionMap" factory-bean="filterChainDefinitionMapBuilder"
          factory-method="builderFilterChainDefinitionMap"/>
    <bean id="filterChainDefinitionMapBuilder"
          class="com.ken.wms.security.service.FilterChainDefinitionMapBuilder"/>

缓存配置文件：ehcache-shiro.xml

<ehcache>
	 <diskStore path="java.io.tmpdir"/>
	 <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />
        <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />
        <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> 
</ehcache>

在Java中

  • 创建FilterChainDefinitionMapBuilder
package com.ken.wms.security.service;

import com.ken.wms.dao.RolePermissionMapper;
import com.ken.wms.domain.RolePermissionDO;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.LinkedHashMap;
import java.util.List;

/**
 * 获取 URL 权限信息工厂类
 * @author ken
 * @since 2017/2/26.
 */
public class FilterChainDefinitionMapBuilder {
    @Autowired
    private RolePermissionMapper rolePermissionMapper;
    private StringBuilder builder = new StringBuilder();

    /**
     * 获取授权信息
     * @return 返回授权信息列表
     */
    public LinkedHashMap<String, String> builderFilterChainDefinitionMap(){
        LinkedHashMap<String, String> permissionMap = new LinkedHashMap<>();

        // 固定的权限配置
        permissionMap.put("/css/**", "anon");
        permissionMap.put("/js/**", "anon");
        permissionMap.put("/fonts/**", "anon");
        permissionMap.put("/media/**", "anon");
        permissionMap.put("/pagecomponent/**", "anon");
        permissionMap.put("/login", "anon");
        permissionMap.put("/account/login", "anon");
        permissionMap.put("/account/checkCode/**", "anon");

        // 可变化的权限配置
        LinkedHashMap<String, String> permissions = getPermissionDataFromDB();
        if (permissions != null){
            permissionMap.putAll(permissions);
        }

        // 其余权限配置
        permissionMap.put("/", "authc");

//        permissionMap.forEach((s, s2) -> {System.out.println(s + ":" + s2);});

        return permissionMap;
    }

    /**
     * 获取配置在数据库中的 URL 权限信息
     * @return 返回所有保存在数据库中的 URL 保存信息
     */
    private LinkedHashMap<String, String> getPermissionDataFromDB(){
        LinkedHashMap<String, String> permissionData = null;

        List<RolePermissionDO> rolePermissionDOS = rolePermissionMapper.selectAll();
        if (rolePermissionDOS != null){
            permissionData = new LinkedHashMap<>(rolePermissionDOS.size());
            String url;
            String role;
            String permission;
            for (RolePermissionDO rolePermissionDO : rolePermissionDOS){
                url = rolePermissionDO.getUrl();
                role = rolePermissionDO.getRole();

                // 判断该 url 是否已经存在
                if (permissionData.containsKey(url)){
                    builder.delete(0, builder.length());
                    builder.append(permissionData.get(url));
                    builder.insert(builder.length() - 1, ",");
                    builder.insert(builder.length() - 1, role);
                }else{
                    builder.delete(0, builder.length());
                    builder.append("authc,roles[").append(role).append("]");
                }
                permission = builder.toString();
//                System.out.println(url + ":" + permission);
                permissionData.put(url, permission);
            }
        }

        return permissionData;
    }

//    /**
//     * 构造角色权限
//     * @param role 角色
//     * @return 返回 roles[role name] 格式的字符串
//     */
//    private String permissionStringBuilder(String role){
//        builder.delete(0, builder.length());
//        return builder.append("authc,roles[").append(role).append("]").toString();
//    }
}
  • 创建domain
/**
 * 用户账户信息（数据传输对象）
 * @author ken
 * @since 2017/2/26.
 */
public class UserInfoDTO {

    /**
     * 用户ID
     */
    private Integer userID;

    /**
     * 用户名
     */
    private String userName;

    /**
     * 用户密码（已加密）
     */
    private String password;

    /**
     * 用户角色
     */
    private List<String> role = new ArrayList<>();
  • 创建realm
/**
 * 用户的认证与授权
 *
 * @author ken
 * @since 2017/2/26.
 */
public class UserAuthorizingRealm extends AuthorizingRealm {

  /**
     * 对用户进行角色授权
     *
     * @param principalCollection 用户信息
     * @return 返回用户授权信息
     */
    @SuppressWarnings("unchecked")
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 创建存放用户角色的 Set
        Set<String> roles = new HashSet<>();

        //获取用户角色
        Object principal = principalCollection.getPrimaryPrincipal();
        if (principal instanceof String) {
            String userID = (String) principal;
            if (StringUtils.isNumeric(userID)) {
                try {
                    UserInfoDTO userInfo = userInfoService.getUserInfo(Integer.valueOf(userID));
                    if (userInfo != null) {
                        // 设置用户角色
                        roles.addAll(userInfo.getRole());
                    }
                } catch (UserInfoServiceException e) {
                    // do logger
                }
            }
        }

        return new SimpleAuthorizationInfo(roles);
    }


 /**
     * 对用户进行认证
     *
     * @param authenticationToken 用户凭证
     * @return 返回用户的认证信息
     * @throws AuthenticationException 用户认证异常信息
     * Realm的认证方法，自动将token传入，比较token与数据库的数据是否匹配
     * 验证逻辑是先根据用户名查询用户，
     * 如果查询到的话再将查询到的用户名和密码放到SimpleAuthenticationInfo对象中，
     * Shiro会自动根据用户输入的密码和查询到的密码进行匹配，如果匹配不上就会抛出异常，
     * 匹配上之后就会执行doGetAuthorizationInfo()进行相应的权限验证。
     */
    @SuppressWarnings("unchecked")
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws
            AuthenticationException {

        String realmName = getName();
        String credentials = "";

        // 获取用户名对应的用户账户信息
        try {
            UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) authenticationToken;
            String principal = usernamePasswordToken.getUsername();

            if (!StringUtils.isNumeric(principal))
                throw new AuthenticationException();
            Integer userID = Integer.valueOf(principal);
            //依赖于/security.service.Interface.UserInfoService,UserInfoDTO中包含用户ID,用户名，密码，角色
            //wms_user表
            UserInfoDTO userInfoDTO = userInfoService.getUserInfo(userID);

            if (userInfoDTO != null) {
                Subject currentSubject = SecurityUtils.getSubject();
                Session session = currentSubject.getSession();

                // 设置部分用户信息到 Session
                session.setAttribute("userID", userID);
                session.setAttribute("userName", userInfoDTO.getUserName());
                //获取该用户的所属仓库
                List<RepositoryAdmin> repositoryAdmin = (List<RepositoryAdmin>) repositoryAdminManageService.selectByID(userInfoDTO.getUserID()).get("data");
                session.setAttribute("repositoryBelong", (repositoryAdmin.isEmpty()) ? "none" : repositoryAdmin.get(0).getRepositoryBelongID());


                // 结合验证码对密码进行处理
                String checkCode = (String) session.getAttribute("checkCode");
                String password = userInfoDTO.getPassword();
                if (checkCode != null && password != null) {
                    checkCode = checkCode.toUpperCase();
                    credentials = encryptingModel.MD5(password + checkCode);
                }
            }
            //比对账号密码
            //principal前端传来userid
            //credentials为数据库的密码，加chexkcode的MD5加密
            //realmName为com.ken.wms.security.realms.UserAuthorizingRealm_0
            return new SimpleAuthenticationInfo(principal, credentials, realmName);

        } catch (UserInfoServiceException | RepositoryAdminManageServiceException | NoSuchAlgorithmException e) {
            throw new AuthenticationException();
        }
    }
  • 创建controller
/**
 * 用户账户请求 Handler
 *
 * @author Ken
 * @since 017/2/26.
 */
@Controller
@RequestMapping("/account")
public class AccountHandler {

// 获取当前的用户的 Subject，shiro
        Subject currentUser = SecurityUtils.getSubject();

  // 判断用户是否已经登陆
        if (currentUser != null && !currentUser.isAuthenticated()) {
            String id = (String) user.get(USER_ID);
            String password = (String) user.get(USER_PASSWORD);
            UsernamePasswordToken token = new UsernamePasswordToken(id, password);

            // 执行登陆操作
            try {
                //会调用realms/UserAuthorizingRealm中的doGetAuthenticationInfo方法
                currentUser.login(token);

                // 设置登陆状态并记录
                Session session = currentUser.getSession();
                session.setAttribute("isAuthenticate", "true");
                Integer userID_integer = (Integer) session.getAttribute("userID");
                String userName = (String) session.getAttribute("userName");
                String accessIP = session.getHost();
                systemLogService.insertAccessRecord(userID_integer, userName, accessIP, SystemLogService.ACCESS_TYPE_LOGIN);

                result = Response.RESPONSE_RESULT_SUCCESS;
            } catch (UnknownAccountException e) {
                errorMsg = "unknownAccount";
            } catch (IncorrectCredentialsException e) {
                errorMsg = "incorrectCredentials";
            } catch (AuthenticationException e) {
                errorMsg = "authenticationError";
            } catch (SystemLogServiceException e) {
                errorMsg = "ServerError";
            }
        } else {
            errorMsg = "already login";
        }

认证流程

  1. 如果没有创建subject，创建一个subject
  2. 调用Subject.login（token）进行登录，其自动委托给Security Manager,调用之前必须通过SecurityUtils.setSecurityManager()设置
  3. SecurityManager负责真正的身份验证逻辑，它会委托给Authenticator进行身份验证
  4. Authenticator才是真正的身份验证者，shiro API中核心身份认证入口点，此处可以自定义插入自己的实现
  5. Authenticator 可能会委托给相应的 Authentication Strategy 进行多 Realm身份验证，默认 MudularRealmAuthenticator 会调用 AuthenticationStrategy进行多Realm身份验证
  6. Authenticator 会把相应的token传入Realm，从Realm获取身份验证信息，如果没有返回抛出异常表示身份验证失败了，此处可以配置多个Realm，按照相应顺序及策略进行访问。
黄盖哥哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
springboot_thymeleaf_shiro.zip
07-05
标题 "springboot_thymeleaf_shiro.zip" 暗示了这个压缩包是一个整合了Spring Boot、Thymeleaf和Shiro的项目实例。这个项目主要是为了实现基于Web的权限控制，通过Spring Boot的便捷性，Thymeleaf的模板引擎功能，...
shiro-demo_DEMO_shiro_shriodemo_shiro框架demo_shiro前后端分离_
10-04
一个实现了shiro前后端分离的框架。拿来就可以用。
shiro用ajax方式登录
热门推荐
白杨
05-23 1万+
用了shiro一段时间了，但是有点受不了它请求登录如果验证不通过直接跳的是loginUrl…所以我想很多人想用ajax实现shiro的登录直接在回调函数里面通过js显示出错信息吧。今天查了一天的资料，结合了别人写的文章，自己也写了这个博客。好了，直接进入主题吧~首先我们知道shiro主要是通过过滤器来实现权限的验证的，你可以继承各种各样的filter来进行扩展。这里我们实现ajax是通过继承Form
shiro 自定义认证filter
xiaoliuliu2050的专栏
02-08 3876
比如说我想 加一个验证码 认证，原来的userNamePasswordToken 就不够用了，我需要自定义一个新的token. public class SecurityToken extends UsernamePasswordToken { /** * 验证码 */ private String captcha; /** * 系统生
spring boot配置shiro自定义shiro filter匹配异常
carllucasyu的博客
03-06 1万+
原文地址：http://www.hillfly.com/2017/179.html最近忙着研究在 Springboot 上使用 Shiro 的问题。刚好就遇到个诡异事，百度 Google 也没找到啥有价值的信息，几番周折自己解决了，这里稍微记录下。自定义 FilterTOCShiro 支持自定义 Filter 大家都知道，也经常用，这里我也用到了一个自定义 Filter，主要用于验证接口调用的 A...
han_Spring Boot
qq_43616155的博客
03-04 203
Spring Boot
Apache_Shiro参考手册中文版_shiro_
10-01
shiro文档 java相关项目开发短信功能使用的jar包
shiro技术大讲堂.rar_highergck_shiro_shiro教程
09-20
shiro使用的详细教程，详尽讲解，并且佐以案例，完全可以掌握！
shiro_shiro_
10-03
shiro source code!!!!
springCloudAlibaba常用的依赖和配置文件
2301_77707071的博客
06-24 153
SpringCloudAlibaba常用pom.xml和配置文件
Spring学习02-[Spring容器核心技术IOC学习]
Java修炼者的博客
06-25 458
IOC学习什么是bean? 什么是bean?
SpringBoot中使用多线程调用异步方法，异步方法有无返回值例子。
L
06-26 379
快速了解@Async注解的用法，包括异步方法无返回值、有返回值，最后总结@Async注解失效的几个坑。在我们的 SpringBoot 应用中，经常会遇到在一个接口中，同时做事情1，事情2，事情3，如果同步执行的话，则本次接口时间取决于事情1 2 3执行时间之和；如果三件事同时执行的话，那么本次接口的运行时间取决于事情1 2 3执行时间最长的那个。合理的使用多线程，可以大大缩短接口的运行时间。几个例子简单的介绍了一下多线程如何调用异步方法的例子。
2.理解Spring IOC 容器设计原理
weixin_40030076的博客
06-26 760
Spring IoC容器提供了多个扩展点，如BeanPostProcessor、BeanFactoryPostProcessor等，允许开发者在容器的运行过程中插入自定义逻辑。Spring IoC容器的实现通常使用模板方法模式，定义了一系列的模板方法，子类可以重写这些方法来实现特定的行为。Spring定义了Bean的生命周期，包括实例化、属性赋值、初始化前回调、初始化后回调、销毁前回调和销毁。容器：Spring IoC容器是一个对象工厂，它负责创建对象、管理对象的生命周期、维护对象间的关系。
Spring的纯注解配置
qq_63242968的博客
06-24 235
【代码】Spring的纯注解配置。
SpringBoot整合WebClient进行Http远程调用
weixin_54158370的博客
06-25 318
SpringBoot整合WebClient进行Http远程调用。
spring模块（二）SpringBean（2）BeanWrapperImpl
w_t_y_y的博客
06-27 137
一、介绍。
基于SpringBoot的藏区特产销售平台
最新发布
heye0910032的博客
06-27 445
随着“互联网+”战略的实施，信息化水平在各行业得到显著提升。然而，藏区特产销售仍多依赖人工管理，效率不高且存在隐患。本研究旨在开发一个藏区特产销售平台，通过信息化手段优化管理流程，提高效率。该平台基于SpringBoot框架，采用B/S模式，以Java开发，集成MySQL数据库，实现特产信息、分类、评分、订单等管理功能，简化工作程序，降低成本。随着“互联网+”战略的实施，信息化水平在各行业得到显著提升。然而，藏区特产销售仍多依赖人工管理，效率不高且存在隐患。
shiro获取session用户_shiro 获取请求头中的 sessionId
05-19
可以使用 Shiro 的 Subject 对象获取当前用户的 Session，具体代码如下： ```java Subject currentUser = SecurityUtils.getSubject(); Session session = currentUser.getSession(); Object sessionId = session....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值