session共享

最新推荐文章于 2024-06-26 20:04:20 发布
最新推荐文章于 2024-06-26 20:04:20 发布
阅读量337 收藏
点赞数
文章标签： session 集群
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chencongbin5/article/details/50723824
版权

多台tomcat 集群的时候 要么ip访问固定指向服务器 要么就只能共享session了
集群 

 upstream web_tomcats {
        ip_hash;//  ip访问固定指向服务器
server 127.0.0.1:7201 weight=10;
server 127.0.0.1:7202 weight=10;
}   
这里 讲共享session  
我们用redis    启动server   ./src/redis-server redis.conf
  redis.conf设置下密码  别让谁都能来玩 
找到#  requirepass 去掉#号  requirepass 后面设置密码
可以启动cli 测试一下
./src/redis-cli 不输入密码
./src/redis-cli -a mima 和输入密码
测试语句  set chen haha

然后spring 配置
<!--jedis pool配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxActive" value="10" />
<property name="maxIdle" value="5" />
<property name="maxWait" value="10" />
<property name="testOnBorrow" value="true" />
</bean>
<!-- jedis pool配置 -->
<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg index="0" ref="jedisPoolConfig" />
<constructor-arg index="1" value="${Jedis.url}" /> 这个就是ip地址  不要输入http://什么的
<constructor-arg index="2" value="6379" /> 这个是端口号
<constructor-arg index="3" value="3000" /> 这个我也不知道
<constructor-arg index="4" value="${Jedis.pwd}" />
</bean>

pom.xml配置  导个包
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.0.0</version>
    <type>jar</type>
    <scope>compile</scope>
</dependency>  
然后写个redis的 service封装一些方法  这里的封装来源宋哥 哈哈

import java.util.List;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.exceptions.JedisException;

/**
 * Redis封装模板及通用方法; 
 * /usr/local/bin/redis-server /etc/redis/6380.conf
 * @author wei
 * 
 */
@Service
public class RedisCacheService {
  Logger logger = Logger.getLogger(RedisCacheService.class);
  
  /**
   * 数据源
   */
  @Autowired private JedisPool jedisPool;

  /**
   * 获取自增id，正整数long 用于jpushsendNo. 
   * 改用redis自身DB支持，不访问数据库
   * 
   * @param  name   业务id， 目前可以使用"jpush","chat_room"
   * @return long 
   */
  public synchronized long getUniqNoSequency(String name){
    return  incr(name + "sequency");
  }


  /**
   *  用户未读信息计数（消息、分享。。一切推送的消息）
   * @param userId 
   * @param reset  清零标记， ture-归零;  默认false
   * @return  0--n  
   */
  public long getMessageCounter(long userId,boolean reset){
    String key= "unreadMessage-"+userId;
    //获取缓存里面的数据
    if(reset){
      del(key);
      return 0;
    }else {
      Long incr = incr(key);
      return incr==null ? 0 : incr;
    }
  }
  

  /******************  下面开始是模板方法！ 上面定义公共函数  ***************************************************/  
  
  /**
   * 执行有返回结果的action。
   */
  protected <T> T execute(JedisAction<T> jedisAction) throws JedisException {
    Jedis jedis = null;
    boolean broken = false;
    try {
      jedis = jedisPool.getResource();
      return jedisAction.action(jedis);
    } catch (JedisConnectionException e) {
      logger.error("Redis connection lost.", e);
      broken = true;
      throw e;
    } finally {
      closeResource(jedis, broken);
    }
  }

  /**
   * 执行无返回结果的action。
   */
  protected void execute(JedisActionNoResult jedisAction) throws JedisException {
    Jedis jedis = null;
    boolean broken = false;
    try {
      jedis = jedisPool.getResource();
      jedisAction.action(jedis);
    } catch (JedisConnectionException e) {
      logger.error("Redis connection lost.", e);
      broken = true;
      throw e;
    } finally {
      closeResource(jedis, broken);
    }
  }

  /**
   * 根据连接是否已中断的标志，分别调用returnBrokenResource或returnResource。
   */
  protected void closeResource(Jedis jedis, boolean connectionBroken) {
    if (jedis != null) {
      try {
        if (connectionBroken) {
          jedisPool.returnBrokenResource(jedis);
        } else {
          jedisPool.returnResource(jedis);
        }
      } catch (Exception e) {
        logger.error("Error happen when return jedis to pool, try to close it directly.", e);
        closeJedis(jedis);
      }
    }
  }

  /**
   * 获取内部的pool做进一步的动作。
   */
  public JedisPool getJedisPool() {
    return jedisPool;
  }

  /**
   * 有返回结果的回调接口定义。
   */
  public interface JedisAction<T> {
    T action(Jedis jedis);
  }

  /**
   * 无返回结果的回调接口定义。
   */
  public interface JedisActionNoResult {
    void action(Jedis jedis);
  }

  // // 常用方法的封装 / //

  // // 公共 ///
  /**
   * 删除key, 如果key存在返回true, 否则返回false。
   */
  public boolean del(final String key) {
    return execute(new JedisAction<Boolean>() {

      @Override
      public Boolean action(Jedis jedis) {
        return jedis.del(key) == 1 ? true : false;
      }
    });
  }

  public void flushDB() {
    execute(new JedisActionNoResult() {

      @Override
      public void action(Jedis jedis) {
        jedis.flushDB();
      }
    });
  }

  // // 关于String ///
  /**
   * 如果key不存在, 返回null.
   */
  public String get(final String key) {
    return execute(new JedisAction<String>() {

      @Override
      public String action(Jedis jedis) {
        return jedis.get(key);
      }
    });
  }

  /**
   * 如果key不存在, 返回0.
   */
  public Long getAsLong(final String key) {
    String result = get(key);
    return result != null ? Long.valueOf(result) : 0;
  }

  /**
   * 如果key不存在, 返回0.
   */
  public Integer getAsInt(final String key) {
    String result = get(key);
    return result != null ? Integer.valueOf(result) : 0;
  }

  public void set(final String key, final String value) {
    execute(new JedisActionNoResult() {

      @Override
      public void action(Jedis jedis) {
        jedis.set(key, value);
      }
    });
  }

  public void setex(final String key, final int seconds, final String value) {
    execute(new JedisActionNoResult() {

      @Override
      public void action(Jedis jedis) {
        jedis.setex(key, seconds, value);
      }
    });
  }

  /**
   * 如果key还不存在则进行设置，返回true，否则返回false.
   */
  public boolean setnx(final String key, final String value) {
    return execute(new JedisAction<Boolean>() {

      @Override
      public Boolean action(Jedis jedis) {
        return jedis.setnx(key, value) == 1 ? true : false;
      }
    });
  }

  public Long incr(final String key) {
    return execute(new JedisAction<Long>() {

      @Override
      public Long action(Jedis jedis) {
        return jedis.incr(key);
      }
    });
  }

  public Long decr(final String key) {
    return execute(new JedisAction<Long>() {

      @Override
      public Long action(Jedis jedis) {
        return jedis.decr(key);
      }
    });
  }

  // // 关于List ///
  public void lpush(final String key, final String value) {
    execute(new JedisActionNoResult() {

      @Override
      public void action(Jedis jedis) {
        jedis.lpush(key, value);
      }
    });
  }

  /**
     * Return the length of the list stored at the specified key. If the key
     * does not exist zero is returned (the same behaviour as for empty lists).
     * If the value stored at key is not a list an error is returned.
   */
  public long llen(final String key) {
    return execute(new JedisAction<Long>() {

      @Override
      public Long action(Jedis jedis) {
        return jedis.llen(key);
      }
    });
  }

  /**
   * 删除List中的第一个等于value的元素，value不存在或key不存在时返回0.
   */
  public boolean lremOne(final String key, final String value) {
    return execute(new JedisAction<Boolean>() {
      @Override
      public Boolean action(Jedis jedis) {
        Long count = jedis.lrem(key, 1, value);
        return (count == 1);
      }
    });
  }

  /**
     * Return the specified elements of the list stored at the specified key.
     * Start and end are zero-based indexes. 0 is the first element of the list
     * (the list head), 1 the next element and so on.
   */
  public List<String> lrange(final String key, final long start, final long end) {
    return execute(new JedisAction<List<String>>() {
      @Override
      public List<String> action(Jedis jedis) {
        return jedis.lrange(key, start, end);
      }
    });

  }

  /**
   * 删除List中的所有等于value的元素，value不存在或key不存在时返回0.
   */
  public boolean lremAll(final String key, final String value) {
    return execute(new JedisAction<Boolean>() {
      @Override
      public Boolean action(Jedis jedis) {
        Long count = jedis.lrem(key, 0, value);
        return (count > 0);
      }
    });
  } 
  
  
  // // 关于Sorted Set ///
  /**
   * 加入Sorted set, 如果member在Set里已存在，只更新score并返回false,否则返回true.
   */
  public boolean zadd(final String key, final String member, final double score) {
    return execute(new JedisAction<Boolean>() {

      @Override
      public Boolean action(Jedis jedis) {
        return jedis.zadd(key, score, member) == 1 ? true : false;
      }
    });
  }

  /**
   * 删除sorted set中的元素，成功删除返回true，key或member不存在返回false。
   */
  public boolean zrem(final String key, final String member) {
    return execute(new JedisAction<Boolean>() {

      @Override
      public Boolean action(Jedis jedis) {
        return jedis.zrem(key, member) == 1 ? true : false;
      }
    });
  }

  /**
   * 返回List长度, key不存在时返回0，key类型不是sorted set时抛出异常.
   */
  public long zcard(final String key) {
    return execute(new JedisAction<Long>() {

      @Override
      public Long action(Jedis jedis) {
        return jedis.zcard(key);
      }
    });
  }

  /**
   * Set a timeout on the specified key
   * @param key
   * @param seconds
   */
  public void expire(final String key, final int seconds) {
    execute(new JedisActionNoResult() {
      @Override
      public void action(Jedis jedis) {
        jedis.expire(key, seconds);
      }
    });
  }
  
  public boolean exists(final String key) {
    return execute(new JedisAction<Boolean>() {
      @Override
      public Boolean action(Jedis jedis) {
        return jedis.exists(key);
      }
    });
  }
  
  
  /**
   * 退出然后关闭Jedis连接。
   */
  public static void closeJedis(Jedis jedis) {
    if (jedis.isConnected()) {
      try {
        try {
          jedis.quit();
        } catch (Exception e) {
        }
        jedis.disconnect();
      } catch (Exception e) {

      }
    }
  } 

}

最后就是一些思路上的问题了
  用户登录 发送请求 登录成功 生成一个32位的MD5字符戳 和用户对象 User
把他当做key value存在redis里面 User弄成json字符串  
比如说 
存
redisCacheService.setex(sessionid, 60*120, new Gson().toJson(user)); // 60*120这个是60秒*120  120分钟啦
取
String cache= redisCacheService.get(token);
 user=new Gson().fromJson(cache, User.class); 

生成的 MD5字符串传回给用户   浏览器存到cookie里面去  每个请求都会自动带cookie来的 嘿嘿 
每次取cache不为null的时候 就再写入一遍  不然过期了 你负责啊
然后基本就成功了




chencongbin5
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【SpringBoot】18、SpringBoot中使用Session共享实现分布式部署
Asurplus
06-10 21万+
前言：我们知道，在单体项目中，我们将用户信息存在 session 中，那么在该 session 过期之前，我们都可以从 session 中获取到用户信息，通过登录拦截，进行操作 但是分布式部署的时候，我们请求的服务器可能不是同一台服务器，那么我们就必须要面对 session 共享的问题，下面介绍的是在 SpringBoot 实现 session 共享的方式 一、创建项目 创建 SpringBoot 项目，选择 Maven 依赖 最终 pom.xml 文件如下： <!-- redis的依赖 --&g
session共享问题
lx_Frolf的博客
01-09 1754
一。session会话机制 由于http 协议的特性是无状态性 ，http 协议本身是无状态的，客户端只需要向服务器请求下载某些文件，无论是客户端还是服务器都没必要记录彼此过去的行为，每一次请求之间对于服务端来说是独立的，如果能够提供一些按照需要生成的动态信息会使 web 变得更加有用。假如一个需要登录授权才能执行的动作，因为 http 协议没办法保存这个登录的用户的状态，因此当下一次再执行一个需...
从Redis缓存服务器获取省市信息
jakeswang的博客
03-17 4799
private List> getProvinceCitiesFromRedis() throws Exception {         JedisTemplate reader = JedisTemplate.getReaderInstance();         String value = reader.get(PROVINCE_CITIES_REDIS_KEY);       
JedisTemplate
weixin_34075551的博客
11-17 699
为什么80%的码农都做不了架构师？>>> ...
对用户登录输入密码错误限制
菜鸟黑一枚
12-28 1728
package com.comtop.map.pub.security; import com.comtop.map.pub.cache.redis.JedisTemplate; import org.apache.shiro.authc.AuthenticationInfo; import org.apache.shiro.authc.AuthenticationToken; import ...
串口编程之三：VMware虚拟机下的串口调试
编程语言小筑
04-07 1001
Windows为宿主机，VMware虚拟机中安装了 Linux，也可以在 Linux 下编写程序对串口发送消息。原理同样是利用虚拟串口软件VSPM 将COM3与COM4连接后通过串口调试器捕获。下面会附上Linux下串口程序的C代码示例。 VSPM的使用和下载参照《串口编程之一：虚拟串口VSPM解决串口编程问题》http://blog.csdn.net/zh405123507/article...
Tomcat session复制及session共享技术
Lzcsfg的博客
06-25 1140
为什么要做session复制或共享Session共享是指在多个服务器之间共享用户会话数据的能力，这对于构建高可用性和可伸缩性的Web应用程序至关重要。实现Session复制或Session共享的目的是为了在多个Tomcat实例之间实现Session的无缝转移和共享，以提供更高的可伸缩性、负载均衡和容错性。
Session共享问题
凉茶铺的博客
07-21 1236
Session共享及Session保持或者叫做Session⼀致性。
session共享学习
ldq18的博客
09-21 2252
session
基于redisson实现tomcat集群session共享
最新发布
Lzcsfg的博客
06-26 1677
基于Redis的Session共享解决了以下几个主要问题： 横向扩展和负载均衡：在传统的Web应用中，为了处理大量请求和保证高可用性，通常会使用多台服务器来横向扩展应用。然而，会话（Session）状态通常保存在单个服务器的内存中，这就导致了当请求被负载均衡到不同服务器时，会话状态无法被共享，用户需要重新登录或者状态丢失。使用Redis作为会话存储后，不同服务器上的应用实例可以通过Redis共享同一份会话数据，从而实现了跨服务器的会话共享，保证了用户的无缝访问体验。 内存利用率提升：传统的会话管理方式是
session共享项目测试
12-17
在IT行业中，尤其是在分布式系统和Web服务开发领域，Session共享是一个关键问题。当多个服务器或服务需要协同工作，为用户提供一致性的会话体验时，如何在集群之间共享Session信息就显得至关重要。本项目"session...
.NET session共享
12-10
.NET Session共享是Web应用程序在分布式部署环境中解决用户会话数据跨服务器传递的一种技术。在传统的单服务器环境下，Session数据存储在服务器本地，但在多服务器负载均衡的场景下，同一个用户的请求可能被分配到...
php实现session共享的实例方法
10-16
首先，关于session共享的需求，一般是由于网站拥有多个子域名，比如***、***和***等，这些子域名需要共享用户的登录状态。如果用户在***登录后，访问***时仍能保持登录状态，就需要实现session共享。默认情况下，PHP...
tomcat8-redis-session共享
11-16
标题 "tomcat8-redis-session共享" 涉及到的是在Tomcat 8中使用Redis作为Session共享存储的解决方案。这是一个常见的需求，特别是在分布式系统中，为了保持用户会话的一致性，需要将Session数据在多台服务器之间共享...
适配与Tomcat7、8、9的redis session共享jar包
07-05
"适配与Tomcat7、8、9的redis session共享jar包"指的是一个专为Apache Tomcat服务器设计的解决方案，用于在多台Tomcat服务器之间共享用户会话数据。这个解决方案主要依赖于Redis，一个高性能的键值存储系统，来存储...
负载均衡3中session共享demo
11-12
大量的并发访问或数据流量分担到多台节点设备上分别处理，减少...但是负载均衡有一个问题就是不同的服务器间进行session共享问题的处理；肯定不可能每分配到一个服务上让用户进行一次登录，这样的用户体验会是极差的；
Springboot实现多服务器session共享
08-26
Springboot实现多服务器session共享 Springboot实现多服务器session共享是指在分布式系统中，每个服务器上的Session可以共享，实现 Session 的同步和共享，从而解决了在分布式环境中Session不一致的问题。下面是...
tomcat集群session共享
06-07
session共享的主要目的是确保用户在集群中的任意一台服务器上操作都能被其他服务器识别，以保持用户的会话连续性。在没有正确处理session共享的情况下，用户可能需要在每次服务器切换时重新登录，这对用户体验极其...
Tomcat下J2EE同域跨项目Session共享详解与代码示例
在J2EE环境中，特别是在使用Tomcat作为应用服务器的情况下，跨域项目间的session共享是一项常见的需求，尤其是在一个Tomcat实例下运行多个Web应用程序（如appA和appB）时。本文将详细介绍如何实现这种session共享，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值