vertx实现redis版session共享

最新推荐文章于 2024-09-01 07:22:58 发布
最新推荐文章于 2024-09-01 07:22:58 发布
阅读量480 收藏
点赞数 1
文章标签： 数据库 java
原文链接：https://segmentfault.com/a/1190000009470700
版权

现在越来越流行微服务架构了，提到微服务架构的话，大家能想到的是spring boot和vertx吧！前者大家听的比交多些，但是今天我给大家分享的是后者vertx。想要了解更多请阅读vertx官网http://vertx.io/docs/vertx-we...

废话不多说了，直接进主题。今天分享的是vertx web里的session共享问题。在公司我用vertx开发了一个web平台，但是需要防止宕机无法继续提供服务这种情况，所以部署了两台机器，这里就开始涉及到了session共享了。为了性能考虑，我就想把session放入redis里来达到目的，可是在vertx官网没有这种实现，当时我就用Hazelcast（网友说，性能不怎么好）将就先用着。前几天我抽时间看了底层代码，自己动手封装了下，将session放入redis里。github地址: https://github.com/robin0909/...

原生vertx session 设计

下面给出 LocalSessionStoreImpl 和 ClusteredSessionStoreImpl 的结构关系:

LocalSession:
localSession核心结构

ClusteredSession:

从上面的结构中我们能找到一个继承实现关系，顶级接口是SessionStore,
而SessionStore是什么接口呢？在vertx里，session有一个专门的设计，这里的SessionStore就是专门为存储session而定义接口，看看这个接口里定义了哪些方法吧！

public interface SessionStore {
  //主要在分布式session共享时会用到的属性，从store里获取session的重试时间
  long retryTimeout();
    
  Session createSession(long timeout);

  //根据sessionId从store里获取Session
  void get(String id, Handler<AsyncResult<@Nullable Session>> resultHandler);

  //删除
  void delete(String id, Handler<AsyncResult<Boolean>> resultHandler);

  //增加session
  void put(Session session, Handler<AsyncResult<Boolean>> resultHandler);

  //清空
  void clear(Handler<AsyncResult<Boolean>> resultHandler);

  //store的size
  void size(Handler<AsyncResult<Integer>> resultHandler);

  //关闭，释放资源操作
  void close();
}

上面很多会用到有一个属性，就是sessionId（id）。在session机制里，还需要依靠浏览器端的cookie。当服务器端session生成后，服务器会在cookie里设置一个vertx-web.session=4d9db69d-7577-4b17-8a66-4d6a2472cd33 返回给浏览器。想必大家也看出来了，就是一个uuid码，也就是sessionId。

接下来，我们可以看下二级子接口。二级子接口的作用，其实很简单，直接上代码，大家就懂了。

public interface LocalSessionStore extends SessionStore {

  long DEFAULT_REAPER_INTERVAL = 1000;

  String DEFAULT_SESSION_MAP_NAME = "vertx-web.sessions";

  static LocalSessionStore create(Vertx vertx) {
    return new LocalSessionStoreImpl(vertx, DEFAULT_SESSION_MAP_NAME, DEFAULT_REAPER_INTERVAL);
  }

  static LocalSessionStore create(Vertx vertx, String sessionMapName) {
    return new LocalSessionStoreImpl(vertx, sessionMapName, DEFAULT_REAPER_INTERVAL);
  }

  static LocalSessionStore create(Vertx vertx, String sessionMapName, long reaperInterval) {
    return new LocalSessionStoreImpl(vertx, sessionMapName, reaperInterval);
  }
}

这里主要为了方面在使用和构造时很优雅，router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx))); 有点类似工厂，创造对象。在这个接口里，也可以初始化一些专有参数。所以没有什么难度。

对官方代码我们也理解的差不多了，接下来开始动手封装自己的RedisSessionStore吧！

自己的RedisSessionStore封装

首先我们定义一个RedisSessionStore接口， 接口继承SessionStore接口。

/**
 * Created by robinyang on 2017/3/13.
 */
public interface RedisSessionStore extends SessionStore {

    long DEFAULT_RETRY_TIMEOUT = 2 * 1000;

    String DEFAULT_SESSION_MAP_NAME = "vertx-web.sessions";

    static RedisSessionStore create(Vertx vertx) {
        return new RedisSessionStoreImpl(vertx, DEFAULT_SESSION_MAP_NAME, DEFAULT_RETRY_TIMEOUT);
    }

    static RedisSessionStore create(Vertx vertx, String sessionMapName) {
        return new RedisSessionStoreImpl(vertx, sessionMapName, DEFAULT_RETRY_TIMEOUT);
    }

    static RedisSessionStore create(Vertx vertx, String sessionMapName, long reaperInterval) {
        return new RedisSessionStoreImpl(vertx, sessionMapName, reaperInterval);
    }

    RedisSessionStore host(String host);

    RedisSessionStore port(int port);
    
    RedisSessionStore auth(String pwd);
}

接着创建一个RedisSessionStoreImpl类, 这里我先给出一个已经写好的RedisSessionStoreImpl, 稍后解释。

public class RedisSessionStoreImpl implements RedisSessionStore {

    private static final Logger logger = LoggerFactory.getLogger(RedisSessionStoreImpl.class);

    private final Vertx vertx;
    private final String sessionMapName;
    private final long retryTimeout;
    private final LocalMap<String, Session> localMap;

    //默认值
    private String host = "localhost";
    private int port = 6379;
    private String auth;

    RedisClient redisClient;

    // 清除所有时使用
    private List<String> localSessionIds;


    public RedisSessionStoreImpl(Vertx vertx, String defaultSessionMapName, long retryTimeout) {
        this.vertx = vertx;
        this.sessionMapName = defaultSessionMapName;
        this.retryTimeout = retryTimeout;

        localMap = vertx.sharedData().getLocalMap(sessionMapName);
        localSessionIds = new Vector<>();
        redisManager();
    }

    @Override
    public long retryTimeout() {
        return retryTimeout;
    }

    @Override
    public Session createSession(long timeout) {
        return new SessionImpl(new PRNG(vertx), timeout, DEFAULT_SESSIONID_LENGTH);
    }

    @Override
    public Session createSession(long timeout, int length) {
        return new SessionImpl(new PRNG(vertx), timeout, length);
    }

    @Override
    public void get(String id, Handler<AsyncResult<Session>> resultHandler) {
        redisClient.getBinary(id, res->{
            if(res.succeeded()) {
                Buffer buffer = res.result();
                if(buffer != null) {
                    SessionImpl session = new SessionImpl(new PRNG(vertx));
                    session.readFromBuffer(0, buffer);
                    resultHandler.handle(Future.succeededFuture(session));
                } else {
                    resultHandler.handle(Future.succeededFuture(localMap.get(id)));
                }
            } else {
                resultHandler.handle(Future.failedFuture(res.cause()));
            }
        });
    }

    @Override
    public void delete(String id, Handler<AsyncResult<Boolean>> resultHandler) {
        redisClient.del(id, res->{
            if (res.succeeded()) {
                localSessionIds.remove(id);
                resultHandler.handle(Future.succeededFuture(true));
            } else {
                resultHandler.handle(Future.failedFuture(res.cause()));
                logger.error("redis里删除sessionId: {} 失败", id, res.cause());
            }
        });
    }

    @Override
    public void put(Session session, Handler<AsyncResult<Boolean>> resultHandler) {
        //put 之前判断session是否存在，如果存在的话，校验下
        redisClient.getBinary(session.id(), res1->{
            if (res1.succeeded()) {
                //存在数据
                if(res1.result()!=null) {
                    Buffer buffer = res1.result();
                    SessionImpl oldSession = new SessionImpl(new PRNG(vertx));
                    oldSession.readFromBuffer(0, buffer);
                    SessionImpl newSession = (SessionImpl)session;
                    if(oldSession.version() != newSession.version()) {
                        resultHandler.handle(Future.failedFuture("Version mismatch"));
                        return;
                    }
                    newSession.incrementVersion();
                    writeSession(session, resultHandler);
                } else {
                    //不存在数据
                    SessionImpl newSession = (SessionImpl)session;
                    newSession.incrementVersion();
                    writeSession(session, resultHandler);
                }
            } else {
                resultHandler.handle(Future.failedFuture(res1.cause()));
            }
        });
    }

    private void writeSession(Session session, Handler<AsyncResult<Boolean>> resultHandler) {

        Buffer buffer = Buffer.buffer();
        SessionImpl sessionImpl = (SessionImpl)session;
        //将session序列化到 buffer里
        sessionImpl.writeToBuffer(buffer);

        SetOptions setOptions = new SetOptions().setPX(session.timeout());
        redisClient.setBinaryWithOptions(session.id(), buffer, setOptions, res->{
            if (res.succeeded()) {
                logger.debug("set key: {} ", session.data());
                localSessionIds.add(session.id());
                resultHandler.handle(Future.succeededFuture(true));
            } else {
                resultHandler.handle(Future.failedFuture(res.cause()));
            }
        });
    }

    @Override
    public void clear(Handler<AsyncResult<Boolean>> resultHandler) {
        localSessionIds.stream().forEach(id->{
            redisClient.del(id, res->{
                //如果在localSessionIds里存在，但是在redis里过期不存在了, 只要通知下就行
                localSessionIds.remove(id);
            });
        });
        resultHandler.handle(Future.succeededFuture(true));
    }

    @Override
    public void size(Handler<AsyncResult<Integer>> resultHandler) {
        resultHandler.handle(Future.succeededFuture(localSessionIds.size()));
    }

    @Override
    public void close() {
        redisClient.close(res->{
            logger.debug("关闭 redisClient ");
        });
    }

    private void redisManager() {
        RedisOptions redisOptions = new RedisOptions();
        redisOptions.setHost(host).setPort(port).setAuth(auth);

        redisClient = RedisClient.create(vertx, redisOptions);
    }

    @Override
    public RedisSessionStore host(String host) {
        this.host = host;
        return this;
    }

    @Override
    public RedisSessionStore port(int port) {
        this.port = port;
        return this;
    }

    @Override
    public RedisSessionStore auth(String pwd) {
        this.auth = pwd;
        return this;
    }
}

首先，从get()和put()这两个方法开始，这两方法比较核心。

  1. get(), 创建Cookie的时候会生成一个uuid,用这个id取session,第一次我们发现无法取到， 第56行代码就会根据这个id去生成一个session。

  2. 每次发送请求的时候，我们都会重置session过期时间，所以每次get完后，返回给浏览器之前都会有一个put操作，也就是更新数据。这里的put就稍微复杂一点点，在put之前，我们需要先根据传过来的session里的id从redis里取到session。如果获取不到，说明之前通过get获取的session不是同一个对象，就出异常，这就相当于设置了一道安全的门槛吧！当获取到了，再比较两个session的版本是不是一致的，如果不一致，说明session被破环了，算是第二个安全门槛设置吧！都没有问题了，就可以put session了，并且重新设置时间。

  3. 这里依赖vertx提供的redisClient来操作数据的，所以我们必须引入这个依赖：io.vertx:vertx-redis-client:3.4.1 。

  4. 接下来还有一点需要提的是序列化问题。这里我使用的是vertx封装的一种序列化，将数据序列化到Buffer里，而SessiomImpl类里又已经实现好了序列化，从SessionImple序列化成Buffer和Buffer反序列化。

public class SessionImpl implements Session, ClusterSerializable, Shareable {
    //...
    
    @Override
  public void writeToBuffer(Buffer buff) {
    byte[] bytes = id.getBytes(UTF8);
    buff.appendInt(bytes.length).appendBytes(bytes);
    buff.appendLong(timeout);
    buff.appendLong(lastAccessed);
    buff.appendInt(version);
    Buffer dataBuf = writeDataToBuffer();
    buff.appendBuffer(dataBuf);
  }

  @Override
  public int readFromBuffer(int pos, Buffer buffer) {
    int len = buffer.getInt(pos);
    pos += 4;
    byte[] bytes = buffer.getBytes(pos, pos + len);
    pos += len;
    id = new String(bytes, UTF8);
    timeout = buffer.getLong(pos);
    pos += 8;
    lastAccessed = buffer.getLong(pos);
    pos += 8;
    version = buffer.getInt(pos);
    pos += 4;
    pos = readDataFromBuffer(pos, buffer);
    return pos;
  }
    
    //...
}

以上就是序列化和反序列化的实现。

  1. localSessionIds 主要考虑到清除session的时候使用，因为数据主要以保存在session为主，本地localSessionIds 保存sessionId是辅助作用。

用法

用法很简单，一行代码就说明。

router.route().handler(SessionHandler.create(RedisSessionStore.create(vertx).host("127.0.0.1").port(6349)));
weixin_34358365
关注
vertx的http服务实现分布式session
lucky_ly的博客
05-04 1460
vertx 的http服务实现分布式session
vertx 4.0 连接redis
AngleFlyyy的博客
04-01 1018
vert.x连接redis需要的依赖： <dependency> <groupId>io.vertx</groupId> <artifactId>vertx-core</artifactId> <version>4.0.0</version> </dependency> <depend
基于vertx-web-sstore-redis的改造实现vertx http应用的分布式session
lucky_ly的博客
07-04 574
只需要将原本的SessionStore换成RedisSessionStore即可。 其本身的Redis客户端是基于vertx实现的，对redis的读写是异步的，不会阻塞io线程。但是其目前的RedisStore实现有个很致命的问题，不能直接支持对自定义对象或者jdk原有的常用对象如ArrayList,HashMap做序列化和反序列化，除8大基本类型和其包装类外，其他的复杂对象都要实现其序列化接口。ClusterSerializable , 复杂对象如果没有实现ClusterSerializable 接口，
Vert.x Redis 客户端教程
gitblog_00869的博客
09-01 795
Vert.x Redis 客户端教程 vertx-redis-clientRedis client for Vert.x项目地址:https://gitcode.com/gh_mirrors/ve/vertx-redis-client 项目介绍 Vert.x Redis 客户端是一个用于与 Redis 数据结构服务器进行交互的异步 API。该项目提供了高性能、非阻塞的 Redis 客户端，适用于...
Vert.x 使用Redis
weixin_33862041的博客
12-13 1594
Redis 首先安装Redis，网上有很多教程，不多说了，说一下Redis的配置文件，让其可以在外网访问 redis.conf # 设置密码 requirepass xxxx # 把下面这一行注释掉 bind 127.0.0.1 # 由 yes 改为 no protected-mode no 复制代码重启 redis ./redis-server redis.conf 复制代码Vert.x po...
Vert.x（vertx）操作Redis
happyfly的博客
09-25 5976
Redis是一个基于Key-Value的非关系型数据库，在项目中经常用来做缓存、分布式锁等。关于Redis的基础知识，这里就不多说了，读者如果对这块内容不熟悉，可以先找些Redis相关的资料来学习。下面我主要来介绍下在Vertx中如何使用Redis，以及底层的实现原理。 基本操作 1.使用Redis和使用数据库一样，只需要导入相关的包，就可以了。这里只需要引入vertx-redis-clien...
Vertx之响应式Redis客户端
Lance
01-12 979
介绍 Vertx响应式mysql客户端，具有简单的API，关注可伸缩性和低开销, 特性: 支持单例redis 支持Sentinel模式 支持Cluster模式 主从（单个分片，一个节点写入，多个读取） 1. maven项目依赖 <dependencies> <dependency> <groupId>io.vertx</groupId> <artifactId>vertx-web</artifactId> &l
vertx-vs-spring-reactor:一个基准，比较使用Groovy，Vertx和vertx-redis-client与Groovy，Spring Reactor和生菜制作的Web服务
05-10
在vert.x示例中，使用Vertx-Redis-Client，并将9个哈希获取请求发送到Redis。 该库使用管道作为默认模式 在弹簧React堆样品中，使用生菜驱动器。 我在某处读到使用React式生菜时流水线是默认模式。 然后，Redis...
vert.x源码解析之redis集成
scientificCommunity的博客
11-10 1309
文章目录前言vertx是什么vertx-redis-client是什么vertx-redis-client有哪些特性怎么使用vertx-redis-client几个核心类的使用方法RedisConnectionredisOptions各项主要配置的含义typemasterNameroleRedisClientSTANDALONE 前言 vertx是什么 vert.x是一个全异步框架，它是reactor线程模型的一种实现，通过内部的event bus跟event loop做到了处处皆异步。关于里面的细节，后面
Vert.x Redis 客户端项目教程
最新发布
gitblog_00589的博客
09-01 846
Vert.x Redis 客户端项目教程 vertx-redis-clientRedis client for Vert.x项目地址:https://gitcode.com/gh_mirrors/ve/vertx-redis-client 1. 项目的目录结构及介绍 Vert.x Redis 客户端项目的目录结构如下： vertx-redis-client/ ├── src/ │ ├── m...
vertx-clustered-session-handler-issue:该示例演示了Vertx 3集群会话StoreSession处理程序的竞争条件
05-08
顶点群集会话处理程序问题 演示以说明Vertx 3.1.0-SNAPSHOT群集会话存储/会话处理程序中存在的竞争条件。 当会话处理程序设置一个异步完成的routingContext.addHeadersEndHandler时，这似乎是一种竞争条件。 当在等待addHeadersEndHandler将来完成操作时对响应进行写入时，似乎发生了腐败（在这种情况下，流是由Pump写入的，但在正常写入时也会发生-即分块的响应）。 该演示使用代理设置来显示许多图像（Google徽标），因此很容易发现流的损坏。 要运行（安装了gradle）： gradle run 或基于Linux且未安装Gradle ./gradlew run 或基于Windows且未安装Gradle gradlew.bat run 加载后，导航至： : : 加载屏幕将显示3个选项： 具有本地会话存储的标
Vert.x配置项VertxOptions的使用
06-04
在发布Vert.x实例时，需要传入一个VertxOptions来实现针对Vert.x的配置项的管理
Android-一言·古诗词API随机返回一条古诗词名句采用Vert.xRedis全异步开发毫秒级稳定响应
08-13
一言·古诗词 API，随机返回一条古诗词名句。采用 Vert.x Redis 全异步开发，毫秒级稳定响应
Vertx-Web初探
06-01
本文主要针对Vert.x的子项目Vert.x Web进行初步探索，了解各种组件用法以及项目实施方式，同时解剖我们开发的项目中使用Vert.x的部分内容。
Vertx的Redis Client进行事务处理
卓小洛的专栏
09-23 2980
Vertx的Redis Client中主要有两个类 RedisClientRedisTransaction 其中RedisTransaction是用来处理Redis缓存事务的。 场景：Redis缓存中有个数据 i=100; 有两个操作，都要对i进行+100的处理 如果不做事务处理： 操作1读Redis缓存i，得到100操作2读Redis缓存i，也得到10
redis 附近的人_vertx+redis实现查找附近的人
weixin_28837357的博客
01-08 167
1.Redis GEO简介Redis GEO实现主要包含了以下两项技术：1、使用geohash保存地理位置的坐标。geohash的思想是将二维的经纬度转换成一维的字符串，geohash有以下三个特点：1.字符串越长，表示的范围越精确。编码长度为8时，精度在19米左右，而当编码长度为9时，精度在2米左右。2.字符串相似的表示距离相近，利用字符串的前缀匹配，可以查询附近的地理位置。这样就实现...
线上redis一般安在linux_老年代又占用100%了，顺便发现了vertx-redis-client 的bug
weixin_39932458的博客
11-29 271
周五中午陆续收到线上广告检索服务某些节点内存不足的报警，这个服务在我们的广告系统中非常重要，所以需要快速止损，立马重启有问题的节点，可是这个时间点真是尴尬，刚好去食堂吃饭了，还好同事机灵在手机上登录云平台，把有问题的节点重启了回到工位后，又陆续收到了相同的报警信息，开始和同事一起排查，找到占用内存过高的进程后，通过查看 gc 情况，发现新生代和老年代都满了，内存得不到释放，遇到这种问题就摩拳擦掌，...
如何正确使用Vertx操作Redis（3.9.4带源码分析和测试结果）
天然玩家的博客
07-01 1915
（1）配置Redis连接地址，通过RedisOptions，该类实例化时，有默认的参数； （2）Vert.x3.9.4提供的Redis客户端无法连接需要密码认证的Redis集群，但是，可以连接单体需要密码认证的Redis； （3）创建连接使用Redis.createClient，该方法根据type选择建立对应的Redis客户端：集群（cluster）、哨兵（sentinel）和单体（standalone）； （4）操作Redis使用RedisAPI完成； （5）Vert.x操作Redis是通过异步线程完成。
Vertx实现自定义游戏后端控制系统的开发与设计
资源摘要信息:"本资源是一个使用Vert.x框架实现的游戏后端控制系统，适用于小型游戏的后台管理。Vert.x是一个基于事件驱动的轻量级Java框架，特别适合构建高并发、响应式的网络应用。本项目的设计与开发，旨在为游戏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值