Springboot+redis实现session共享与单点登录---随笔

最新推荐文章于 2023-12-07 11:02:37 发布
最新推荐文章于 2023-12-07 11:02:37 发布
阅读量392 收藏 3
点赞数
分类专栏： java 文章标签： redis session java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39668819/article/details/105760596
版权
导入依赖
 <!--redis-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>
 <!--session-->
 <dependency>
     <groupId>org.springframework.session</groupId>
     <artifactId>spring-session-data-redis</artifactId>
 </dependency>
编码实现

Redis配置

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置
 * @author savesl
 */
@Configuration
public class RedisConfig {
	@Autowired
	private RedisConnectionFactory factory;

	@Bean
	public RedisTemplate<String, Object> redisTemplate() {
		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
		redisTemplate.setKeySerializer(new StringRedisSerializer());
		redisTemplate.setHashKeySerializer(new StringRedisSerializer());
		redisTemplate.setHashValueSerializer(new StringRedisSerializer());
		redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
		redisTemplate.setConnectionFactory(factory);
		return redisTemplate;
	}

	@Bean
	public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
		return redisTemplate.opsForHash();
	}

	@Bean
	public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
		return redisTemplate.opsForValue();
	}

	@Bean
	public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
		return redisTemplate.opsForList();
	}

	@Bean
	public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
		return redisTemplate.opsForSet();
	}

	@Bean
	public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
		return redisTemplate.opsForZSet();
	}
}

RedisSession共享配置

import org.springframework.context.annotation.Configuration;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

/**
 * @author savesl
 * maxInactiveIntervalInSeconds  设置session过期时间为40*60秒【默认30分钟】
 */
@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 2400)
public class RedisSessionConfig {

}

Redis工具类

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 * @author savesl
 */
@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    /**
     * String类型
     */
    @Autowired
    private ValueOperations<String, String> valueOperations;
    /**
     * hash类型
     */
    @Autowired
    private HashOperations<String, String, Object> hashOperations;
    /**
     * list类型
     */
    @Autowired
    private ListOperations<String, Object> listOperations;
    /**
     * set类型
     */
    @Autowired
    private SetOperations<String, Object> setOperations;
    /**
     * sorted set类型
     */
    @Autowired
    private ZSetOperations<String, Object> zSetOperations;
    /**
     * 默认过期时长，单位：秒
     */
    public final static long DEFAULT_EXPIRE = 60 * 60 * 24;
    /**
     * 不设置过期时长
     */
    public final static long NOT_EXPIRE = -1;


    // region 通用

    /**
     * 正则表达式匹配查找key  数据量如果比较大不要使用，可以用scan代替
     * @param pattern 正则表达式
     * @return 存放key的list集合
     */
    public Set<String> getKeys (String pattern) {
        return redisTemplate.keys(pattern);
    }


    // endregion 通用

    // region string类型
    public void set(String key, Object value, long expire) {
        valueOperations.set(key, toJson(value));
        if (expire != NOT_EXPIRE) {
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    }

    public void set(String key, Object value) {
        set(key, value, DEFAULT_EXPIRE);
    }

    public <T> T get(String key, Class<T> clazz, long expire) {
        String value = valueOperations.get(key);
        if (expire != NOT_EXPIRE) {
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value == null ? null : fromJson(value, clazz);
    }

    public <T> T get(String key, Class<T> clazz) {
        return get(key, clazz, NOT_EXPIRE);
    }

    public String get(String key, long expire) {
        String value = valueOperations.get(key);
        if (expire != NOT_EXPIRE) {
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value;
    }

    public String get(String key) {
        return get(key, NOT_EXPIRE);
    }

    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 增加数量
     * @param i 递增数量
     * @return
     */
    public long incr(String key,int i) {
        return valueOperations.increment(key, i);
    }

    /**
     * 递增，每次+1
     * @return
     */
    public long incr(String key) {
//		System.out.println(key);
//		System.out.println(valueOperations);
        return valueOperations.increment(key, 1);
    }

    /**
     * 获取当前递增过的对应key的value值
     * @param key
     * @return
     */
    public long getIncrValue(String key) {
        return valueOperations.increment(key, 0);
    }

    // endregion string类型



    //region list类型
    /**
     * 获取list类型的数据    取全部数据start:0  end:-1
     * @param key
     * @param start 第一个是0 第二个是1 以此类推……
     * @param end 最后一个是-1 倒数第二个为-2 以此类推……
     * @return
     */
    public List<Object> lget(String key,long start,long end){
        return listOperations.range(key, start, end);
    }

    /**
     * 返回list类型数据的数据量，数据个数
     * @param key
     * @return
     */
    public int lsize(String key){
        return listOperations.size(key).intValue();
    }

    /**
     * 定长存入list中，只保存key对应的最近length条记录。
     * 先清理掉length-1之后的数据，然后在开头位置插入最新的数据。
     * @param key
     * @param data 数据
     * @param length 固定长度，超出length-2范围的数据会被清理
     * @return
     */
    public void pushFixLength(String key,Object data,int length) {
        //清理掉过剩的数据
        listOperations.trim(key, 0, length-2);
        //从开头保存最新的数据
        listOperations.leftPush(key, data);
    }


    // endregion list类型




    //region list-hash混合处理
    /**
     * 返回一个list中保存key的 hash类型数据集合 ，即hash类型数据的key保存在一个list中，通过list的key以获取多个hash中的数据
     * @param key list集合的key
     * @param start list的起始位置，第一个为0
     * @param end list的最后位置，倒数第一个为-1
     * @param pre hash 的key的前缀
     * @param suf hash 的key的后缀
     * @return hash数据的集合
     *
     */
    public List<Map<String,Object>> lhget(String key,long start,long end,String pre,String suf){
        List<Map<String,Object>> listMap = new ArrayList<>();
        List<Object> keys = listOperations.range(key, start, end);
        for(Object k : keys) {
            Map<String, Object> entrie = hashOperations.entries(pre+(String)k+suf);
            if(!entrie.isEmpty()) {
                listMap.add(entrie);
            }
        }
        return listMap;
    }

    // endregion list-hash混合处理



    // region hash类型
    /**
     * 获取指定key中的hash类型数据中的键值对
     * @param key
     */
    public Map<String,Object> hget(String key){
        return hashOperations.entries(key);
    }



    // endregion hash类型



    // region z-set类型

    /**
     * 指定的数据的分值自增（+1）
     */
    public double zIncr(String k,String v) {
        return zSetOperations.incrementScore(k, v, 1);
    }

    /**
     * 指定的数据分值增加给定的值（+n）
     */
    public double zIncr(String k,String v,int step) {
        return zSetOperations.incrementScore(k, v, step);
    }

    /**
     * 获取key为k的有序的分数从min到max的数据
     * @param k 键
     * @param min 最小值
     * @param max 最大值
     */
    public Set<String> zRangByScore(String k,double min,double max){
        Set<Object> setObj = zSetOperations.rangeByScore(k,min,max);
        return (Set<String>)(Set<?>)setObj;
    }

    /**
     * 获取key为k的有序的分数从min到max数据 中的从offset开始 共count个元素
     * @param k 键
     * @param min 最小值
     * @param max 最大值
     */
    public Set<String> zRangByScore(String k,double min,double max,long offset, long count){
        Set<Object> setObj = zSetOperations.rangeByScore(k,min,max,offset,count);
        return (Set<String>)(Set<?>)setObj;
    }

    /**
     * 倒序 获取key为k的有序的分数从min到max的数据
     * @param k 键
     * @param min 最小值
     * @param max 最大值
     */
    public Set<String> zReverseRangeByScore(String k,double min,double max){
        Set<Object> setObj = zSetOperations.reverseRangeByScore(k,min,max);
        return (Set<String>)(Set<?>)setObj;
    }

    /**
     * 获取key为k的有序的分数从min到max数据 中的从offset开始 共count个元素
     * @param k 键
     * @param min 最小值
     * @param max 最大值
     */
    public Set<String> zReverseRangeByScore(String k,double min,double max,long offset, long count){
        Set<Object> setObj = zSetOperations.reverseRangeByScore(k,min,max,offset,count);
        return (Set<String>)(Set<?>)setObj;
    }

    /**
     * 获取key为k的 分数从min到max数据的总数
     * @param k 键
     * @param min 最小值
     * @param max 最大值
     */
    public long zCount(String k,double min,double max){
        return zSetOperations.count(k,min,max);
    }

    /**
     * 返回指定键和值的分值
     * @param k 键
     * @return 返回分值
     */
    public Double zScore(String k,String val){
        return zSetOperations.score(k, val);
    }



    // endregion z-set类型



    /**
     * Object转成JSON数据
     */
    public String toJson(Object object) {
        if (object instanceof Integer || object instanceof Long || object instanceof Float || object instanceof Double || object instanceof Boolean || object instanceof String) {
            return String.valueOf(object);
        }
        return JSON.toJSONString(object);
    }

    /**
     * JSON数据，转成Object
     */
    public <T> T fromJson(String json, Class<T> clazz) {
        return JSON.parseObject(json, clazz);
    }


    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }


    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    public ValueOperations<String, String> getValueOperations() {
        return valueOperations;
    }


    public void setValueOperations(ValueOperations<String, String> valueOperations) {
        this.valueOperations = valueOperations;
    }


    public HashOperations<String, String, Object> getHashOperations() {
        return hashOperations;
    }


    public void setHashOperations(HashOperations<String, String, Object> hashOperations) {
        this.hashOperations = hashOperations;
    }


    public ListOperations<String, Object> getListOperations() {
        return listOperations;
    }


    public void setListOperations(ListOperations<String, Object> listOperations) {
        this.listOperations = listOperations;
    }


    public SetOperations<String, Object> getSetOperations() {
        return setOperations;
    }


    public void setSetOperations(SetOperations<String, Object> setOperations) {
        this.setOperations = setOperations;
    }


    public ZSetOperations<String, Object> getzSetOperations() {
        return zSetOperations;
    }


    public void setzSetOperations(ZSetOperations<String, Object> zSetOperations) {
        this.zSetOperations = zSetOperations;
    }



}

yml配置

spring:
  redis:
    database: 0 数据库索引，从0开始
    host: 服务器IP
    port: redis端口
    password: 密码
    timeout: 20000ms
    jedis:
      pool:
        max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms      # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 10      # 连接池中的最大空闲连接
        min-idle: 5       # 连接池中的最小空闲连接
  session:
    store-type: redis

单点登录实现

 /**
   * 登录处理
   * @param session
   * @return
   */
 @RequestMapping(value = "/verifyAccount", method = RequestMethod.POST)
    @ResponseBody
    public Result verifyAccount(String accountName, String password, HttpSession session){
        if(StringUtil.isBlank(accountName) || StringUtil.isBlank(password)){
            return Result.error("参数错误");
        }
        AccountEntity account = accountService.findAccountByName(accountName);
        if(null == account || account.getStatus().equals("F")){
            return Result.error("该账号不存在或已禁用");
        }

        //获取redis中该用户对应的 sessionId
        String sessionId = redisUtils.get("loginAccount:"+account.getId());
        //若sessionId不为空，即：已登录
        if(StringUtil.isNotBlank(sessionId)){
            String currentSessionId = session.getId();
            if(!currentSessionId.equals(sessionId)){
                return Result.error("该账号已在其他设备登录!");
            }
        }

        if(!account.getPassword().equals(password)){
            return Result.error("密码错误");
        }

        List<String> authorization = accountService.findAllMenuByAccount(account.getId());
        Set<String> permissionSet = new HashSet<>();
        for (String auth : authorization) {
            if (StringUtils.isBlank(auth)) {
                continue;
            }
            permissionSet.addAll(Arrays.asList(auth.trim().split(",")));
        }
        account.setPermissionSet(permissionSet);
        session.setAttribute("account", account);
		
        redisUtils.set("loginAccount:"+account.getId(), session.getId(), 60*40);
        return Result.ok("登录成功!");
    }

   /**
     * 退出登录
     * @param session
     * @return
     */
    @RequestMapping("/logOut")
    public String logOut(HttpSession session){
        AccountEntity account = (AccountEntity)session.getAttribute("account");
        //设置过期
        redisUtils.set("loginAccount:"+account.getId(), session.getId(), 0);
        session.removeAttribute("account");
        return "common/login";
    }
akieay
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于SpringBoot+Redis的Session共享与单点登录详解
08-25
主要介绍了基于SpringBoot+Redis的Session共享与单点登录,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot Redis Session
宇宙小神特别萌
11-13 2324
文章目录Redis1、前提springboot配置redis：2、集成redis session方式1：yml配置方式2：注解配置 Redis 1、前提springboot配置redis： <!--redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-bo
SpringBoot 全家桶 | SpringSession + Redis实现会话共享
人生就是一个不断学习的过程
09-08 2081
官方介绍 Spring Session 提供了一个 API 和实现，用于管理用户的会话信息，同时使其在不依赖于特定于应用程序容器的解决方案的情况下，可以轻松地支持集群会话。它还提供了透明的集成： HttpSession 允许以中立的方式替换应用程序容器(即 Tomcat)中的HttpSession，并支持在 Headers 中提供会话 ID 以与 RESTful API 一起使用。 WebSocket 能够在接收 WebSocket 消息时使HttpSession保持活动状态 WebSession 允许以
springboot-redis-session
夜猫子与猫头鹰
02-02 573
一、Spring Boot对Redis的支持 Spring对Redis的支持是使用Spring Data Redis来实现的，一般使用Jedis或者lettuce（默认），Java客户端在 org.springframework.boot.autoconfigure.data.redis（Spring Boot 2.x） 中redis的自动配置 AutoConfigureDataRedis 　　　　　　　　　　　　　　　　　　 RedisAutoConfiguration提供了RedisTem.
SpringBoot项目使用Spring Session，将Session保存在Redis中。
qq_42804736的博客
07-01 7300
我们之前实现Java的会话管理功能，主要是使用Cookie或Session。 Cookie是客户端技术，服务器把数据以cookie的形式保存在用户的浏览器中 Session是服务器端技术，服务器把数据以session的形式保存在服务器中 在分布式情况下，session会失效，比如项目部署在多台服务器中，服务器之间无法共享session，用户在A服务器上已经登录了，但当负载均衡跳转到服务器B时，由于B服务器并没有用户的登录信息，session就失效了，用户就退出了登录。 一旦服务器关闭或重启也
第十四章 ： Spring Boot 整合spring-session,使用redis共享
最新发布
RodJohnsonDoctor的专栏
12-07 1185
本文重点讲述：spring boot工程中使用spring-session机制进行安全认证，并且通过redis存储session，满足集群部署、分布式系统的session共享。
springboot +shiro+redis实现session共享（方案二）1
08-08
springboot +shiro+redis实现session共享（方案二）1
SpringBoot+MyBatis+SpringSession+Redis实现session共享及单点登录
03-02
SpringBoot+MyBatis+SpringSession+Redis实现session共享及单点登录开发实例
SpringBoot+Vue+Redis实现单点登录(一处登录另一处退出登录)
08-25
小编接到一个需求，需要实现用户在浏览器登录后，跳转到其他页面，当用户在其它地方又登录时，前面用户登录的页面退出登录，这篇文章主要介绍了SpringBoot+Vue+Redis实现单点登录,需要的朋友可以参考下
vue+springboot+redis+kaptcha实现登录验证码
04-10
vue+springboot+redis+kaptcha实现登录页验证码
基于springboot和redis实现单点登录
08-25
主要为大家详细介绍了基于springboot和redis实现单点登录，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
springboot + redis实现session共享
12-22
通过本代码，可以搭建springboot + redis实现session共享。利用redis特性可以进行分布式session共享。
Spring Boot + Spring Session + Redis
11-14
项目说明博客地址：http://blog.csdn.net/qq_17616169/article/details/53150893
springboot+redis+session共享机制分析
weixin_41657954的博客
04-26 2986
springboot+redis+session共享机制分析 1.简介： springboot+redis+session共享机制分析其实是模拟实现单点登录的一种方式。在日常开发中，不可避免出现一个业务需要在不同的项目上一起运作才能完成，为了避免每个关联项目都要从新登录的问题，就有了单点登录的概念。一般实现单点登录的思路就是将登录状态的标志进行共享，这个标志可以是session，token等充当！我这里就使用session来作为共享标志。 2.该框架的总体思路： 1.将redis作为存放session的容器
SpringSession单点登录（Single Sign On）
asmall_cat的博客
05-09 2133
什么是单点登录 单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一。SSO 的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统，企业间需互相授信。 -->微服务 客户端-->-------------<--sso服务 -->微服务 一、 分布式系统 Session 共享方案 1 分布式系统中 HttpSession...
springboot利用session实现单点登录
m0_60459789的博客
11-27 1784
检查session的方法，判断当前session中是否有用户登录信息，没有的话说明没登录，返回true，如果存在登录信息，取出当前sessionId以及servletcontext中此用户id对应的sessionId，判断两个sessionId是否相等，相等的话，说明是同一个连接会话，也返回true。这里我用的是登录成功后的应该界面的跳转，来测试功能有没有实现，如果实现的话，我们在例外一个浏览器登录是就会把最开始登录的那个浏览器挤掉，进行操作的话就需要从新登录。如果是被挤到的，那么给前端一个1的状态。
最新版Spring Security & Spring Session 实现单点登录
weixin_43626356的博客
08-23 1293
Spring Security & Spring Session & Redis实现SSO
单点登录实现（spring session+redis完成session共享）
算命de博客
03-22 1090
一、前言 项目中用到的SSO，使用开源框架cas做的。简单的了解了一下cas，并学习了一下 单点登录的原理，有兴趣的同学也可以学习一下，写个demo玩一玩。 二、工程结构 我模拟了 sso的客户端和sso的服务端， sso-core中主要是一些sso需要的过滤器和工具类，缓存和session共享的一些XML配置文件，还有springmvc需要的一下jar包的管理。sso-cache...
SpringBoot Session Redis 实现与简析
风语落尘
10-18 4238
一、Spring Session Redis 1、配置spring session redis相关maven依赖 &lt;!-- redis --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-r...
springboot+mybatis+springsession+redis实现session共享及单点登录
09-01
使用SpringBoot框架结合MyBatis实现Session共享和单点登录可以借助SpringSession和Redis来实现。 首先，需要配置SpringSession以使用Redis作为存储方式。可以在SpringBoot的配置文件中添加以下配置： ``` spring.session.store-type=redis spring.session.redis.namespace=spring:session spring.redis.host=127.0.0.1 spring.redis.port=6379 ``` 这样配置后，SpringSession会自动将session信息存储到Redis中。 接着，在登录验证成功后，将用户信息存储到Redis中，并将该用户的唯一标识存储到当前Session的属性中，以便后续验证是否登录。例如： ``` @RequestMapping("/login") public String login(@RequestParam("username") String username, @RequestParam("password") String password, HttpSession session) { // 验证用户名和密码 // ... // 验证通过后，将用户信息存储到Redis中，并设置Session属性 redisTemplate.opsForHash().put("user:" + username, "username", username); session.setAttribute("username", username); return "success"; } ``` 在后续的请求中，可以通过拦截器或过滤器来验证Session是否有效。例如： ``` @Component public class SessionInterceptor implements HandlerInterceptor { @Autowired private RedisTemplate<String, Object> redisTemplate; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { HttpSession session = request.getSession(); String username = (String) session.getAttribute("username"); if (StringUtils.isEmpty(username)) { response.sendRedirect("/login"); return false; } String storedUsername = (String) redisTemplate.opsForHash().get("user:" + username, "username"); if (!StringUtils.equals(storedUsername, username)) { response.sendRedirect("/login"); return false; } return true; } } ``` 以上代码片段展示了如何通过拦截器验证Session的有效性。首先从当前Session中获取用户名，如果为空则重定向到登录页面。然后从Redis中获取存储的用户名，如果与当前用户名不匹配，则重定向到登录页面。 这样就实现了SpringBoot、MyBatis、SpringSession和Redis共同完成Session共享和单点登录的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值