欢迎来到哔的博客

1
import cn.dev33.satoken.context.model.SaRequest
2
import io.vertx.core.http.HttpServerRequest
3
import io.vertx.ext.web.RoutingContext
4
import java.util
5
import scala.jdk.CollectionConverters.*
6

7
// 请求对象，携带着一次请求的所有参数数据
8
class VertxRequest(ctx: RoutingContext) extends SaRequest {
9
  val request: HttpServerRequest = ctx.request()
10
  override def getSource: HttpServerRequest = request
11

12
  override def getParam(name: String): String = Option(request.getParam(name)).getOrElse("")
13

14
  override def getParamNames: util.Collection[String] = request.params().names()
15

16
  override def getParamMap: util.Map[String, String] = request.params().asScala.map(entry => entry.getKey -> entry.getValue).toMap.asJava
17

18
  override def getHeader(name: String): String = Option(request.getHeader(name)).getOrElse("")
19

20
  override def getCookieValue(name: String): String = Option(request.getCookie(name).getValue).getOrElse("")
21

22
  override def getCookieFirstValue(name: String): String = Option(request.cookies(name).asScala.head.getValue).getOrElse("")
23

24
  override def getCookieLastValue(name: String): String = Option(request.cookies(name).asScala.last.getValue).getOrElse("")
25

26
  override def getRequestPath: String = Option(request.uri()).getOrElse("")
27

28
  override def getUrl: String = Option(request.absoluteURI()).getOrElse("")
29

30
  override def getMethod: String = Option(request.method().name()).getOrElse("")
31

32
  // SaToken 1.41.0 需要新增实现以下方法
33
  // override def getHost: String = request.authority().host()
34

35
  // 请求转发
36
  override def forward(path: String): AnyRef = {
37
    ctx.reroute(path)
38
    null
39
  }
40
}

1
import cn.dev33.satoken.context.model.SaResponse
2
import io.vertx.core.http.HttpServerResponse
3
import io.vertx.ext.web.RoutingContext
4

5
// 响应对象，携带着对客户端一次响应的所有数据
6
class VertxResponse(ctx: RoutingContext) extends SaResponse {
7
  val response: HttpServerResponse = ctx.response()
8
  override def getSource: HttpServerResponse = response
9

10
  override def setStatus(sc: Int): SaResponse = {
11
    response.setStatusCode(sc)
12
    this
13
  }
14

15
  override def setHeader(name: String, value: String): SaResponse = {
16
    response.putHeader(name, value)
17
    this
18
  }
19

20
  override def addHeader(name: String, value: String): SaResponse = {
21
    response.putHeader(name, value)
22
    this
23
  }
24

25
  // 重定向
26
  override def redirect(url: String): AnyRef = ctx.redirect(url)
27
}

1
import cn.dev33.satoken.context.model.SaStorage
2
import io.vertx.ext.web.RoutingContext
3
import java.util
4

5
// 请求上下文对象，提供 [一次请求范围内] 的上下文数据读写
6
class VertxStorage(ctx: RoutingContext) extends SaStorage {
7
  val storage: util.Map[String, AnyRef] = ctx.data()
8
  override def getSource: util.Map[String, AnyRef] = storage
9

10
  override def get(key: String): AnyRef = Option(storage.get(key)).orNull
11

12
  override def set(key: String, value: AnyRef): SaStorage = {
13
    storage.put(key, value)
14
    this
15
  }
16

17
  override def delete(key: String): SaStorage = {
18
    storage.remove(key)
19
    this
20
  }
21
}

1
import cn.dev33.satoken.context.SaTokenContext
2
import cn.dev33.satoken.context.model.{SaRequest, SaResponse, SaStorage}
3
import io.vertx.ext.web.RoutingContext
4
import scala.compiletime.uninitialized
5

6
// 单例对象
7
object VertxTokenContext {
8
  // 懒加载创建单例实例
9
  private lazy val instance: VertxTokenContext = new VertxTokenContext()
10

11
  // 获取单例实例
12
  def apply(ctx: RoutingContext): VertxTokenContext = {
13
    // 设置当前请求的 RoutingContext
14
    instance.SetRoutingContext(ctx)
15
    instance
16
  }
17
}
18

19
// SaToken 上下文处理器
20
class VertxTokenContext private extends SaTokenContext {
21
  // uninitialized 表示变量未初始化，访问未初始化的变量会抛出 UninitializedFieldError
22
  // 与 `= _` 不同，uninitialized 不会将变量初始化为默认值（如 null、0 等）
23
  // `= _` 是 Scala 2 中表示变量未初始化的方式
24
  private var ctx: RoutingContext = uninitialized
25

26
  // 设置当前请求的 RoutingContext
27
  def SetRoutingContext(ctx: RoutingContext): Unit = this.ctx = ctx
28

29
  // 获取当前请求的 [Request] 对象
30
  override def getRequest: SaRequest = VertxRequest(ctx)
31

32
  // 获取当前请求的 [Response] 对象
33
  override def getResponse: SaResponse = VertxResponse(ctx)
34

35
  // 获取当前请求的 [存储器] 对象
36
  override def getStorage: SaStorage = VertxStorage(ctx)
37

38
  // 校验指定路由匹配符是否可以匹配成功指定路径
39
  override def matchPath(pattern: String, path: String): Boolean = PathMatcher.MatchPath(pattern, path)
40
}

1
import redis.RedisExample // 自定义 Redis 实例
2
import cats.effect.IO
3
import cats.effect.kernel.Resource
4
import cats.effect.unsafe.implicits.global
5
import cn.dev33.satoken.dao.SaTokenDao
6
import cn.dev33.satoken.session.SaSession
7
import cn.dev33.satoken.util.SaFoxUtil
8
import cn.hutool.json.JSONUtil
9
import dev.profunktor.redis4cats.RedisCommands
10
import dev.profunktor.redis4cats.effects.{KeyScanArgs, RedisType}
11
import java.util
12
import scala.concurrent.duration.*
13
import scala.jdk.CollectionConverters.*
14

15
// 若是 SaToken 1.41.0，可以继承 SaTokenDaoDefaultImpl 类而不是实现 SaTokenDao 接口
16
class RedisTokenDao extends SaTokenDao {
17
  // 此处引入自定义的 Redis 实例（Redis4jCats），此处的 Redis 实例是短连接，
18
  // 也可以使用 Jedis 连接池创建长连接实例
19
  val redis: Resource[IO, RedisCommands[IO, String, String]] = RedisExample.api
20

21
  override def update(key: String, value: String): Unit = {
22
    val expire = getTimeout(key)
23
    if (expire == SaTokenDao.NOT_VALUE_EXPIRE) return
24
    set(key, value, expire)
25
  }
26

27
  override def getTimeout(key: String): Long = {
28
    redis
29
      .use { r =>
30
        r.ttl(key).flatMap {
31
          case Some(duration) => IO.pure(duration.toSeconds)
32
          case None           => IO.pure(0L)
33
        }
34
      }
35
      .unsafeRunSync()
36
  }
37

38
  override def set(key: String, value: String, timeout: Long): Unit = {
39
    if (timeout == 0 || timeout <= SaTokenDao.NOT_VALUE_EXPIRE) return
40
    // 判断是否为永不过期// 判断是否为永不过期
41
    if (timeout == SaTokenDao.NEVER_EXPIRE)
42
      redis.use(r => r.set(key, value)).unsafeRunSync()
43
    else redis.use(r => r.setEx(key, value, timeout.seconds)).unsafeRunSync()
44
  }
45

46
  override def getObject(key: String): AnyRef = {
47
    redis
48
      .use { r =>
49
        r.get(key).flatMap {
50
          case Some(value) =>
51
            IO.pure(SaSessionUtil.GetSession(JSONUtil.parse(value)))
52
          case None => IO.pure(null)
53
        }
54
      }
55
      .unsafeRunSync()
56
  }
57

58
  override def updateObject(key: String, `object`: Any): Unit = {
59
    val expire = getTimeout(key)
60
    if (expire == SaTokenDao.NOT_VALUE_EXPIRE) return
61
    setObject(key, `object`, expire)
62
  }
63

64
  // 此处的 `object` 即是 SaSession 对象，直接使用 Hutool JSON 序列化成字符串存入 Redis
65
  override def setObject(key: String, `object`: Any, timeout: Long): Unit = {
66
    if (timeout == 0 || timeout <= SaTokenDao.NOT_VALUE_EXPIRE) return
67
    if (timeout == SaTokenDao.NEVER_EXPIRE)
68
      redis
69
        .use(r => r.set(key, JSONUtil.toJsonPrettyStr(`object`)))
70
        .unsafeRunSync()
71
    else
72
      redis
73
        .use(r =>
74
          r.setEx(key, JSONUtil.toJsonPrettyStr(`object`), timeout.seconds)
75
        )
76
        .unsafeRunSync()
77
  }
78

79
  override def deleteObject(key: String): Unit = delete(key)
80

81
  override def delete(key: String): Unit =
82
    redis.use(r => r.del(key)).unsafeRunSync()
83

84
  override def getObjectTimeout(key: String): Long = getTimeout(key)
85

86
  override def updateObjectTimeout(key: String, timeout: Long): Unit =
87
    updateTimeout(key, timeout)
88

89
  override def updateTimeout(key: String, timeout: Long): Unit = {
90
    // 判断是否想要设置为永久
91
    if (timeout == SaTokenDao.NEVER_EXPIRE) {
92
      val expire = getTimeout(key)
93
      if (expire != SaTokenDao.NEVER_EXPIRE) {
94
        // 如果尚未被设置为永久，那么再次set一次
95
        this.set(key, this.get(key), timeout)
96
      }
97
      return
98
    }
99
    redis.use(r => r.expire(key, timeout.seconds)).unsafeRunSync()
100
  }
101

102
  override def get(key: String): String = {
103
    redis
104
      .use { r =>
105
        r.get(key).flatMap {
106
          case Some(value) => IO.pure(value)
107
          case None        => IO.pure(null)
108
        }
109
      }
110
      .unsafeRunSync()
111
  }
112

113
  /** 搜索数据，获取所有匹配的键，不是键值对
114
   *
115
   * @param prefix 前缀
116
   * @param keyword 关键字
117
   * @param start 开始处索引
118
   * @param size 获取数量 (-1代表从 start 处一直取到末尾)
119
   * @param sortType 排序类型（true=正序，false=反序）
120
   * @return 查询到的数据集合
121
   */
122
  override def searchData(
123
      prefix: String,
124
      keyword: String,
125
      start: Int,
126
      size: Int,
127
      sortType: Boolean
128
  ): util.List[String] = {
129
    val list: List[String] = redis
130
      .use { cmd =>
131
        // s"$prefix*$keyword*"：表示匹配前缀为 prefix，并且包含 keyword 的所有键
132
        val pattern = s"$prefix*$keyword*"
133
        val keyScanArgs = KeyScanArgs(RedisType.String, pattern, 30)
134
        cmd.scan(keyScanArgs).map(cursor => cursor.keys)
135
      }
136
      .unsafeRunSync()
137
    SaFoxUtil.searchList(list.asJava, start, size, sortType)
138
  }
139

140
  // 优先执行下面的方法而不是 getObject/setObject... 等方法
141
  override def setSession(session: SaSession, timeout: Long): Unit = setObject(session.getId, session, timeout)
142
  override def updateSession(session: SaSession): Unit = updateObject(session.getId, session)
143
  override def deleteSession(sessionId: String): Unit = deleteObject(sessionId)
144
  override def getSessionTimeout(sessionId: String): Long = getObjectTimeout(sessionId)
145
  override def updateSessionTimeout(sessionId: String, timeout: Long): Unit = updateObjectTimeout(sessionId, timeout)
146

147
  // SaToken 1.41.0 需要实现以下方法，可以通过直接继承 SaTokenDaoDefaultImpl 类重写调用父类方法，
148
  // 只有 1.41.0 的 SaTokenDaoDefaultImpl 才实现了 getObject[T](key: String, classType: Class[T]): T 方法
149
  // override def getObject[T](key: String, classType: Class[T]): T = super.getObject(key, classType)
150
}

1
import cn.dev33.satoken.session.SaSession;
2
import cn.dev33.satoken.session.TokenSign; // SaToken 1.41.0 没有该类！！
3
import cn.hutool.json.JSON;
4
import cn.hutool.json.JSONUtil;
5

6
public class SaSessionUtil {
7
  public static SaSession GetSession(JSON source) {
8
    return new SaSession() {{
9
      setId(source.getByPath("id").toString());
10
      setType(source.getByPath("type").toString());
11
      setLoginType(source.getByPath("loginType").toString());
12
      setLoginId(source.getByPath("loginId"));
13
      setCreateTime(Long.parseLong(source.getByPath("createTime").toString()));
14
      setDataMap(JSONUtil.parseObj(source.getByPath("dataMap")));
15
      // SaToken 1.41.0 没有该属性！！
16
      setTokenSignList(JSONUtil.parseArray(source.getByPath("tokenSignList")).toList(TokenSign.class));
17
    }};
18
  }
19
}

1
import cn.dev33.satoken.SaManager
2
import cn.dev33.satoken.stp.StpUtil
3
import io.vertx.core.Vertx
4
import io.vertx.ext.web.Router
5
import io.vertx.ext.web.handler.BodyHandler
6
import vertx.User
7

8
// https://sa-token.cc/doc.html#/fun/sa-token-context
9
object Application extends App {
10
  val vertx = Vertx.vertx() // 创建 Vert.x 实例
11
  val router: Router = Router.router(vertx) // 创建路由
12
  router.route().handler(BodyHandler.create()) // 启用请求体解析
13

14
  // 设置 SaToken 的存储层为 Redis
15
  SaManager.setSaTokenDao(RedisTokenDao())
16

17
  router.route().handler(ctx => {
18
    // 设置 SaToken 上下文实例，经过测试每一次调用请求都需要设置上下文，
19
    // 此处的上下文对象使用单例确保全局只创建一次
20
    SaManager.setSaTokenContext(VertxTokenContext(ctx))
21
    ctx.next()
22
  })
23

24
  router.get("/login").handler { ctx =>
25
    // 会话登录
26
    StpUtil.login("Dorothy", "PC")
27
    val user = User("Dorothy", 16)
28
    StpUtil.getSession().set("user", user.toString)
29
    ctx.response()
30
      .putHeader("Content-Type", "application/json")
31
      .end(s"""{"msg": "Hello, ${user.name}!"}""")
32
  }
33

34
  router.get("/info").handler { ctx =>
35
    // 判断是否登录
36
    if StpUtil.isLogin then {
37
      val userStr = StpUtil.getSession().get("user").asInstanceOf[String]
38
      val user = userStr match {
39
        case s"User($name,$age)" => User(name, age.toByte)
40
        case _ => throw new IllegalArgumentException("转换失败！")
41
      }
42
      ctx.response()
43
        .putHeader("Content-Type", "application/json")
44
        .end(
45
          s"""{
46
             |"name": "${user.name}",
47
             |"age": "${user.age}"
48
             |}""".stripMargin)
49
    } else ctx.response().putHeader("Content-Type", "application/json").end("""{"msg": "未登录"}""")
50
  }
51

52
  // 启动服务器并监听 2234 端口
53
  vertx.createHttpServer()
54
    .requestHandler(router)
55
    .listen(2234, "0.0.0.0", { result =>
56
      if result.succeeded() then println("Server is now listening on http://127.0.0.1:2234!")
57
      else println(s"Failed to start server: ${result.cause()}")
58
    })
59
}

1
{
2
  "id": "satoken:login:session:Dorothy",
3
  "type": "Account-Session",
4
  "loginType": "login",
5
  "loginId": "Dorothy",
6
  "createTime": 1742651367502,
7
  "dataMap": {
8
    "user": "User(Dorothy,16)"
9
  },
10
  "tokenSignList": [
11
    {
12
      "value": "94f2c820-8a8a-4ecd-ba55-5c9e513bcc3f",
13
      "device": "PC"
14
    },
15
    {
16
      "value": "38cfce02-dc79-45fe-a50d-79f427a846a8",
17
      "device": "PE"
18
    }
19
  ]
20
}