Shiro结合JWT实现单点登录

最新推荐文章于 2024-08-30 09:02:29 发布
最新推荐文章于 2024-08-30 09:02:29 发布
阅读量1.8k 收藏 1
点赞数 1
分类专栏： shiro 文章标签： shiro 单点登陆

简述

Apache Shiro是java的一个安全框架，Shiro可以帮助我们完成认证、授权、加密、会话管理、与Web集成、缓存等。而且Shiro的API也比较简单，这里我们就不进行过多的赘述，想要详细了解Shiro的，推荐看开涛的博客（点这里）

在Shiro的强大权限管理的基础上，我们实现单点登录就容易了很多，结合我上篇博客所讲的JSON Web Token（推荐先看这篇博客）就可以完成单点登录系统。

实现过程

在使用Shiro实现登录的时候，将登录成功的信息包括Token信息返回给前端，前端在请求后台时，将Token信息存入请求头中。配置自定义拦截器，拦截所有URL请求，取出请求头信息中的Token信息，对Token信息进行验证，对于redis中存在的登录时生成的Token信息，如果Token信息正确，则确认该用户已经登录，否则拒绝请求，返回401错误。

1.引入所需jar包

        <!--json-web-token-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
        </dependency>
        <!--shiro-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
        </dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

2.登录认证

要实现单点登录功能，首先要完成的就是登录功能，这里我们使用Shiro的认证来完成登录。

2.1 spring-shiro的配置文件
<!--配置SecurityManager-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realms">
            <list>
                <ref bean="shiroRealm"/>
            </list>
        </property>
    </bean>

    <!--配置Realm-->
    <!--直接配置实现了org.apache.shiro.realm.Realm接口的bean-->
    <bean id="shiroRealm" class="com.why.authority.realms.ShiroRealm">
        <!-- 凭证匹配器：配置登录验证所使用的加密算法-->
        <property name="credentialsMatcher">
            <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                <property name="hashAlgorithmName" value="sha-512"/>
                <property name="hashIterations" value="1024"/>
            </bean>
        </property>
    </bean>

    <!-- shiro拦截器-->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="/user/index"/>
        <!--配置哪些页面需要受保护
            1. anon 可以被匿名访问
            2. authc 必须认证(登录)后才可能访问的页面
            3. logout 登出
        -->

        <!--自定义filters,该拦截器即为实现单点登录的拦截器-->
        <property name="filters">
            <map>
                <entry key="acf">
                    <bean class="com.why.authority.filter.AccessingControlFilter"/>
                </entry>
            </map>
        </property>
        <property name="filterChainDefinitions">
            <value>
                /user/index=anon
                /user/login=anon
                /user/content= acf
                /** = acf
            </value>
        </property>
    </bean>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
2.2 登录方法

Controller：

@RequestMapping(value = {"/login"}, method = RequestMethod.POST)
    @ResponseBody
    public WhyResult content(@RequestParam("usercode") String usercode, @RequestParam("password") String password) {

        String userInfoKey = "aum:user:" + usercode;
        String tokenKey = "aum:token:"+usercode;

        try {
            if(StringUtils.isBlank(usercode) || StringUtils.isBlank(password)){
                throw new UnknownAccountException();
            }
            //1. 执行登录
            //把用户名和密码封装为UsernamePasswordToken对象
            UsernamePasswordToken token = new UsernamePasswordToken(usercode, password);
            SecurityUtils.getSubject().login(token);

            //2.获取用户信息userEntity,redis中不存在则存入redis
            UserEntity userEntity = new UserEntity();
            //2.1 从redis中获取或从数据库中获取
            String strUserInfo = JedisCacheUtil.get(userInfoKey);
            if (!StringUtils.isBlank(strUserInfo)) {
                userEntity = JacksonJsonUntil.jsonToPojo(strUserInfo, UserEntity.class);
            } else {
                userEntity = addUserInfoToRedis(usercode, userInfoKey);
            }
            //3.生成Token信息并保存到redis
            LoginEntity loginEntity = addTokenToRedis(userEntity,tokenKey);
            return WhyResult.build(200,"登录成功！",loginEntity);
            //所有认证异常的父类
        } catch (AuthenticationException e) {
            logger.error("登录失败！",e);
            return WhyResult.build(401,"用户名或密码错误！");
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

自定义Realm

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

        //1.把AuthenticationToken转换为UsernamePasswordToken
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;

        //2.从UsernamePasswordToken中获取userCode
        String userCode = usernamePasswordToken.getUsername();
        String userInfoKey = "aum:user:" + userCode;
        UserEntity userEntity;
        //3.获取用户信息userEntity
        //3.1 从redis中获取
        String strUserInfo;
        try {
            strUserInfo = JedisCacheUtil.get(userInfoKey);
            if (!StringUtils.isBlank(strUserInfo)) {
                userEntity = JacksonJsonUntil.jsonToPojo(strUserInfo, UserEntity.class);
            } else {
                userEntity = addUserAndGetUser(userCode, userInfoKey);
            }
        } catch (Exception e) {
            userEntity = addUserAndGetUser(userCode, userInfoKey);
        }
        //6.根据用户的情况，来构建AuthenticationInfo对象并返回
        String credentials = userEntity.getPassword();
        //使用ByteSource.Util.bytes()来计算盐值
        ByteSource credentialsSalt = ByteSource.Util.bytes(userCode);

        return new SimpleAuthenticationInfo(userEntity, credentials, credentialsSalt, getName());

    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

3. 自定义拦截器

该拦截器是在spring-shiro.xml文件中配置的自定义拦截器，原理就是拦截每个请求，验证URL请求头信息中的Token信息是否过期，是否被篡改。

@Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        //是否验证通过
        boolean bool = false;
        try {
            HttpServletRequest req = WebUtils.toHttp(servletRequest);
            String firstLoginToken = req.getParameter("token");

            //从token中获得信息
            Claims claims = TokenUtil.getClaims(firstLoginToken);
            String userCode = claims.getSubject();
            String userId = claims.getId();

            String redisLoginKey = "aum:token:" + userCode;
            String redisToken = JedisCacheUtil.get(redisLoginKey);
            if(!StringUtils.isBlank(redisToken)){
                String[] arrayRedisToken = redisToken.split("@");
                //将用户传过来的token和redis中的做对比，若一样，认为已经登录
                if (arrayRedisToken[0].equals(firstLoginToken)) {
                    //比较这次访问与登录的时间间隔有多少分钟,如果大于5分钟，则更新redis中的上次访问时间信息，将过期时间从新设定为30分钟
                    long diffMin = TokenUtil.CompareTime(arrayRedisToken[1]);
                    if (diffMin >= 5) {
                        String currentAccessTime = PasswordUtil.base64Encoede(String.valueOf(System.currentTimeMillis()));
                        //更新redis中的token登录信息
                        JedisCacheUtil.set(redisLoginKey, arrayRedisToken[0] + "@" + currentAccessTime, 30 * 60);
                    }
                    bool=true;
                }
            }
        } catch (Exception e) {
            return bool;
        }
        return bool;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

至此为止，关键代码已经展示完了，现在实现的仅仅是最基础的单点登录，还需要进行更多的安全检查和验证，这里就不介绍了。

Shiro+JWT
qq_32699009的博客
09-13 2294
apache旗下的一个开源框架，实现用户身份认证，权限授权，加密，会话管理等功能 内容均转载自Shiro和JWT MD5加密 概述 MD5消息摘要算法，属Hash算法一类。MD5算法对输入任意长度的消息进行运行，产生一个128位的消息摘要(32位的数字字母混合码)。 也就是0123456789ABCDEF构成的混合数字码 特点 不可逆：相同数据的MD5值肯定一样，不同数据的MD5值不一样。 压缩性：任意长度的数据，算出的MD5值长度都是固定的 弱抗碰撞：已知原数据和MD5值，想找到一个具有相同MD5值是非常
shiro+jwt如何实现单点登录
weixin_35755434的博客
01-09 443
使用 Shiro JWT 实现单点登录可以分为以下几步： 在服务端配置 Shiro JWT 过滤器，使其能够识别和验证 JWT 令牌。 在用户登录时，服务端生成 JWT 令牌并返回给客户端。 客户端在发起请求时，将 JWT 令牌放在 HTTP 头部的认证信息中，发送给服务端。 服务端通过 Shiro JWT 过滤器验证 JWT 令牌的有效性。如果令牌有效，则允许用户访问；否则，拒绝用户访问...
推荐项目：Shiro-JWT —— 简化你的认证授权之路
最新发布
gitblog_00754的博客
08-30 426
推荐项目：Shiro-JWT —— 简化你的认证授权之路 shiro-jwt项目地址:https://gitcode.com/gh_mirrors/sh/shiro-jwt 随着微服务和分布式系统的兴起，安全而高效的认证机制成为了开发者关注的焦点。Apache Shiro作为Java界广泛使用的权限管理框架，结合JSON Web Tokens（JWT）的轻量级特性，诞生了一个强大的组合——shi...
Springboot整合shiro+jwt---实现单点登录，权限认证和控制+实现代码
热门推荐
drnrrwfs的博客
04-26 1万+
shiro用来认证用户及权限控制，jwt用来生成一个token，暂存用户信息。jwt生成一个token存储在客户端，每次请求将其存储在header中，解决了跨域，可以通过自定义的方法进行验证，解决了分布式验证的问题。 大体包含哪些类 （1）LoginAction.java （controller层）。 （2）JwtUtil.java(工具类)：实现了利用登陆信息生成token，更新token，根据token获取username，token验证等方法。 （3）JWTFilter.java（过滤器）：拦截除登陆
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ 在微服务中我们一般采用的是无状态登录，而传统的session方式，在前后端分离的微服务架构下，如继续使用则必将要解决跨域sessionId问题、...
shiro+ springMVC + Redis+mysql 实现 单点登录
12-06
"Shiro+SpringMVC+Redis+MySQL实现单点登录"是一个典型的系统安全架构，它整合了多个技术组件来构建一个高效、可靠的单点登录（Single Sign-On, SSO）解决方案。以下是关于这个主题的详细知识点： 1. **Apache ...
shiro+jwt如何实现单点登录,代码实例
09-03
Shiro 支持使用 JSON Web Token (JWT) 实现单点登录 (SSO)。 实现步骤如下： 1. 在服务端生成 JWT 并返回给客户端。 2. 客户端保存 JWT 并在请求中加上 HTTP Header，如 "Authorization: Bearer JWT"。 3. 服务端...
【shiro+jwt整合的单点登录】
m0_72583612的博客
05-21 430
这些东西都是死的,照着抄就完事了,咱们不啰嗦,直接上代码提示：以下是本篇文章正文内容，下面案例可供参考//用户登录//校验和数据库 中的用户名密码是否一致//校验和数据库 中的用户名密码是否一致单点登录可以搭配着昨天的网关一起使用,昨天的网关代码也有对token的拦截,判断以及解析。
shiro-jwt-oauth权限认证
11-11
包含两个项目模块，一个是基于jwt的token认证方式，一个是基于shiro-jwt-oatuh的认证方式。
JWT实现的单点登录系统Demo
02-01
基于JWT实现的单点登录系统，使用idea开发的，可以供学习参考，有什么问题可以咨询
shiro实现单点登录
10-15
spring整合shirospring-data-redis和spring-session-data-redis通过shiro实现单点登录
oauth2-shiro-jwt:两种登录方式
05-14
接口说明，支持两种方式，两套接口 1.使用JWT生成Token，使用shiro实现鉴权 2.使用oauth2生成token，spring security实现鉴权 使用JWT生成Token，使用shiro实现鉴权 UMS返回参数说明 名称 类型 说明 type int 请求状态(0:失败;1:成功) messageCode int 详情请移步错误码page message String 提示信息 result Object 结果集 获取token POST /shiro/auth/token 输入参数 必须 类型 中文描述 applicationKey yes String 需要登录的项目key userName yes String 用户名 password yes String 密码 返回Result 类型 中文描述 token String 使用JWT生成的Token 请求示例 cu
SpringBoot + Redis + Shiro + JWT单点登录主流安全框架
欢迎。
01-29 2273
SpringBoot集成Redis、Shiro、JWT
Springboot+shiro单点登录实现.md
09-15
Springboot+shiro单点登录实现，本文档是单点登录的全部源代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值