当前位置：首页 > article >正文

学习笔记--基于Sa-Token 实现Java项目单点登录+同端互斥检测

article 2025/3/29 2:35:23

同端互斥登录

单点登录SSO

架构选型

模式二: URL重定向传播

前后端分离

整体流程

准备工作

搭建客户端

搭建认证中心SSO Server

环境配置

开放认证接口

启动类

跨域处理

同端互斥登录

同端互斥登陆模块

同端互斥登录指：同一类型设备上只允许单地点登录，在不同类型设备上允许同时在线。比如 QQ 可以手机电脑同时在线，但是不能在两个手机上同时登录一个账号。具体步骤如下

sa-token:
  # token 名称（同时也是 cookie 名称）
  token-name: praxisAI
  # token 有效期（单位：秒） 默认30天，-1 代表永久有效
  timeout: 2592000
  # token 最低活跃频率（单位：秒），如果 token 超过此时间没有访问系统就会被冻结，默认-1 代表不限制，永不冻结
  active-timeout: -1
  # 是否开启同端互斥登录 （false开启）
  is-concurrent: false   
  # 在多人登录同一账号时，是否共用一个 token （为 true 时所有登录共用一个 token, 为 false 时每次登录新建一个 token）
  is-share: true
  # token 风格（默认可取值：uuid、simple-uuid、random-32、random-64、random-128、tik）
  token-style: uuid
  # 是否输出操作日志
  is-log: true

在配置文件中，将 isConcurrent 配置为false
DeviceUtils工具类：判断前端请求传来的设备信息，比如pc，后续设置到Sa-Token登录态中

//设备工具类
public class DeviceUtils {

    //根据请求获取设备信息
    public static String getRequestDevice(HttpServletRequest request) {
        String userAgentStr = request.getHeader(Header.USER_AGENT.toString());
        // 使用 Hutool 解析 UserAgent
        UserAgent userAgent = UserAgentUtil.parse(userAgentStr);
        ThrowUtils.throwIf(userAgent == null, ErrorCode.OPERATION_ERROR, "非法请求");
        // 默认值是 PC
        String device = "pc";
        // 是否为小程序
        if (isMiniProgram(userAgentStr)) {
            device = "miniProgram";
        } else if (isPad(userAgentStr)) {
            // 是否为 Pad
            device = "pad";
        } else if (userAgent.isMobile()) {
            // 是否为手机
            device = "mobile";
        }
        return device;
    }

    /**
     * 判断是否是小程序
     * 一般通过 User-Agent 字符串中的 "MicroMessenger" 来判断是否是微信小程序
     **/
    private static boolean isMiniProgram(String userAgentStr) {
        // 判断 User-Agent 是否包含 "MicroMessenger" 表示是微信环境
        return StrUtil.containsIgnoreCase(userAgentStr, "MicroMessenger")
                && StrUtil.containsIgnoreCase(userAgentStr, "MiniProgram");
    }

    /**
     * 判断是否为平板设备
     * 支持 iOS（如 iPad）和 Android 平板的检测
     **/
    private static boolean isPad(String userAgentStr) {
        // 检查 iPad 的 User-Agent 标志
        boolean isIpad = StrUtil.containsIgnoreCase(userAgentStr, "iPad");

        // 检查 Android 平板（包含 "Android" 且不包含 "Mobile"）
        boolean isAndroidTablet = StrUtil.containsIgnoreCase(userAgentStr, "Android")
                && !StrUtil.containsIgnoreCase(userAgentStr, "Mobile");

        // 如果是 iPad 或 Android 平板，则返回 true
        return isIpad || isAndroidTablet;
    }
}

3. 登录时传入参数

// 使用 Sa-Token 登录，并指定设备，同端登录互斥
StpUtil.login(user.getId(), DeviceUtils.getRequestDevice(request));

//例如 调用此方法登录后，同设备的会被顶下线（不同设备不受影响）
StpUtil.login(10001, "PC");

Sa-Token 在背后做了大量的工作，包括

检查此账号是否之前已有登录，为账号生成 Token（uuid 风格）凭证与 Session 会话
记录 Token 活跃时间；
通知全局侦听器，xx 账号登录成功；
将 Token 注入到请求上下文返回给前端 等等其它工作……（利用cookie自动注入特性）
1. Cookie 可以从后端控制往浏览器中写入 token 值。
2. Cookie 会在前端每次发起请求时自动提交 token 值。

JWT token模式

//1、登录成功后：后端将 token 返回到前端
SaTokenInfo tokenInfo = StpUtil.getTokenInfo();  //包括tokenName和tokenValue
return SaResult.data(tokenInfo);  //返回给前端 

//2.前端保存到localstorge中，下次请求带上
//3.后端Sa-Token 就能像传统PC端一样自动读取到 token 值，进行鉴权

记住我模式

原理：调用StpUtil.login(10001, true)，在浏览器写入一个持久Cookie储存 Token，此时用户即使重启浏览器 Token 依然有效。

Sa-Token的登录授权，默认就是[记住我]模式，为了实现[非记住我]模式，你需要在登录时如下设置

// 设置登录账号id为10001，第二个参数指定是否为[记住我]，当此值为false后，关闭浏览器后再次打开需要重新登录
StpUtil.login(10001, false);

注销模块

// 检验当前会话是否已经登录, 如果未登录，则抛出异常：`NotLoginException`：代表当前会话暂未登录
StpUtil.checkLogin();
// 移除登录态
StpUtil.logout();

获取当前登录用户

// 获取当前会话账号id, 如果未登录，则返回 null 
Object loginUserId = StpUtil.getLoginIdDefaultNull();
if (loginUserId == null) {
    throw new BusinessException(ErrorCode.NOT_LOGIN_ERROR);
}
User currentUser = this.getById((String) loginUserId);
if (currentUser == null) {
    throw new BusinessException(ErrorCode.NOT_LOGIN_ERROR);
}
return currentUser;

单点登录SSO

Sa-Token

单点登录举个例子理解

假设系统被切割为多个部分：商城、论坛、直播、社交…… 如果用户每访问一个模块都要登录一次，那么这样就很麻烦了，为了优化用户体验，需要一套机制将这N个系统的认证授权互通共享，让用户在一个系统登录之后，可以畅通无阻的访问其它所有系统。

凡是稍微上点规模的系统，统一认证中心都是绕不过去的槛。

架构选型

系统架构	采用模式	简介	文档链接
前端同域 + 后端同 Redis	模式一	共享 Cookie 同步会话	文档、示例
前端不同域 + 后端同 Redis	模式二	URL重定向传播会话	文档、示例
前端不同域 + 后端不同 Redis	模式三	Http请求获取会话	文档、示例

前端同域：指多个系统可以部署在同一个主域名之下，比如：c1.domain.com、c2.domain.com、c3.domain.com。
后端同Redis：指多个系统可以连接同一个Redis，PS：这里并不需要把所有项目的数据都放在同一个Redis中，Sa-Token提供了 [权限缓存与业务缓存分离] 的解决方案，详情戳： Alone独立Redis插件。
模式三：Http请求获取会话（Sa-Token对SSO提供了完整的封装，只需要复制几段代码便可以轻松集成）

根据本项目场景，后端同Redis，所以选择模式二+ 前后端分离架构

SaToken SSO优势

API 简单易用，且官方文档介绍很详细。
支持三种模式，是否跨域、是否共享Redis、是否前后端分离等场景很轻松解决
内置域名校验、密钥校验、Token防窃取，安全性很高
不丢参数，相比其他单点登录框架，Sa-Token-SSO内有专门的算法保证了参数不丢失，登录成功之后原路返回页面。

模式二: URL重定向传播

如果多个系统部署在不同的域名之下，但是后端可以连接同一个Redis，那么便可以使用 [URL重定向传播会话] 的方式做到单点登录

首先我们再次复习一下，多个系统之间为什么无法同步登录状态？

前端的Token无法在多个系统下共享。

后端的Session无法在多个系统间共享。

第二点官方已使用 Alone独立Redis插件做到权限缓存直连 SSO-Redis 数据中心，不再赘述。

未登录，客户端页面显示“登录”链接。

点击登录，携带当前页面back参数(包含客户端host)，跳转到当前客户端的/sso/login接口

未登录时，重定向到SSO服务器的登录页

用户在SSO登录页登录成功后，SSO服务器返回ticket，重定向回指定客户端

客户端通过SaSsoClientProcessor向SSO服务器验证ticket的有效性，获取用户ID

使用StpUtil.login(userId)在本地登录用户

在跨域模式下， "共享Cookie方案" 的失效，所以必须采用一种新的方案来传递Token。

`前后端分离`

首先理解对于一个前后端分离项目，即我们的系统，整体流程是这样的

前端==>后端==>重定向到SSO认证中心（展示页面，所以SSO服务器代码是前后端不分离的，主要作用就是：展示登录页，校验登录和重定向）

这种情况要考虑跨域，即客户端与 SSO 服务器部署在不同域，缺点：前端需主动调用 /sso/getSsoAuthUrl 获取登录地址，并处理重定向逻辑

`整体流程`

前端页面点击 [登录] 后触发调用登录函数，调用后端接口/sso/login，并携带back参数( 包含客户端host )
- 形如：http://{sso-client}/sso/login?back=xxx
若子系统检测到此用户尚未登录，则直接重定向到SSO认证中心，并携带redirect参数（记录子系统的登录页URL）
- 形如：http://{sso-server}/sso/auth?redirect=xxx?back=xxx
用户进入 SSO认证中心的登录页面，开始登录。
用户输入账号密码并登录成功，SSO认证中心下放ticket码参数。重定向回客户端的登录接口/sso/login
- 形如：http://{sso-client}/sso/login?back=xxx&ticket=xxxxxxxxx
客户端通过SaSsoClientProcessor向SSO服务器验证ticket的有效性，获取用户ID，使用StpUtil.login(userId)在本地登录用户
其他客户端尝试登录后，前面步骤一样，到了请求发到SSO服务器，会通过sso/auth判断是否已经登录（已登录内部是通过redis查看用户id来判断的）然后直接返回Ticket进行登录即可

整个过程，除了第四步用户在SSO认证中心登录时会被打断，其余过程均是自动化的

当用户在另一个子系统再次点击[登录]按钮，由于此用户在SSO认证中心已有会话存在，所以第四步也将自动化，也就是单点登录的最终目的 一次登录，处处通行。

流程如下

`准备工作`

首先修改hosts文件(C:\Windows\System32\drivers\etc\hosts)，添加以下IP映射，方便测试：

127.0.0.1 sa-sso-server.com    #ip映射，用于测试多个客户端单点登录
127.0.0.1  sa-sso-client1.com   
127.0.0.1 sa-sso-client2.com

`搭建客户端`

客户端就是我们的后端服务器，考虑到前后分离架构，比如用VUE3前端，下面是一个模拟的前端例子

<!-- 项目首页 -->
<template>
  <h2> Sa-Token SSO-Client 应用端（前后端分离版-Vue3） </h2>
  <p>当前是否登录：<b>{{isLogin}}</b></p>
  <p>
    <router-link :to="loginUrl">登录</router-link>&nbsp;&nbsp;  <!--点击登录后携带back参数请求后端sso/login接口-->
  </p>
</template>

<script setup>
import { ref } from 'vue'
import {baseUrl, ajax} from './method-util.js'

// 单点登录地址
const loginUrl = '/api/sso/login?back=' + encodeURIComponent(location.href);
// 是否登录
const isLogin = ref(false);

// 1.查询当前会话是否登录
ajax('/api/sso/isLogin', {}, function (res) {
  console.log('/isLogin 返回数据：', res);
  isLogin.value = res.data;
})
</script>

<!-- Sa-Token-SSO-Client端-登录页 -->
<template>
</template>
<script setup>
import {onMounted} from "vue";
import {ajax, getParam} from './method-util.js';
import router from '../router';

// 获取参数
const back = getParam('back') || router.currentRoute.value.query.back;
const ticket = getParam('ticket') || router.currentRoute.value.query.ticket;

    
console.log('获取 back 参数：', back)
console.log('获取 ticket 参数：', ticket)

// 页面加载后触发
onMounted(() => {
  if(ticket) {    //2.如果ticket存在，则尝试通过ticket登录
    doLoginByTicket(ticket);
  } else {
    goSsoAuthUrl();  //3.不存在，则重定向至认证中心
  }
})

// 重定向至认证中心方法
function goSsoAuthUrl() {
  ajax('/api/sso/getSsoAuthUrl', {clientLoginUrl: location.href}, function(res) {
    console.log('/api/sso/getSsoAuthUrl 返回数据', res);
    location.href = res.data;
  })
}

// 根据ticket值登录 方法
function doLoginByTicket(ticket) {
  ajax('/api/sso/doLoginByTicket', {ticket: ticket}, function(res) {
    console.log('/api/sso/doLoginByTicket 返回数据', res);
    if(res.code === 200) {
      localStorage.setItem('satoken', res.data);
      location.href = decodeURIComponent(back);
    } else {
      alert(res.msg);
    }
  })
}
</script>

搭建后端

环境配置

<!-- Sa-Token 权限认证，在线文档：https://sa-token.cc -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-spring-boot-starter</artifactId>
            <version>1.40.0</version>
        </dependency>
        <!-- Sa-Token 整合 Redis （使用 jackson 序列化方式） -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-redis-jackson</artifactId>
            <version>1.40.0</version>
        </dependency>
        <!-- 提供Redis连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!-- Sa-Token 插件：整合SSO -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-sso</artifactId>
            <version>1.40.0</version>
        </dependency>
        <!-- Sa-Token插件：权限缓存与业务缓存分离 -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-alone-redis</artifactId>
            <version>1.40.0</version>
        </dependency>

配置文件中整合sso-client相关配置+API密钥+redis存ticket

sa-token:
  # token 名称（同时也是 cookie 名称）
  token-name: praxisAI
  # token 有效期 2天（单位：秒） 默认30天，-1 代表永久有效
  timeout: 172800
  # token 最低活跃频率（单位：秒），如果 token 超过此时间没有访问系统就会被冻结，默认-1 代表不限制，永不冻结
  active-timeout: -1
  # 是否开启同端互斥登录 （false开启）
  is-concurrent: false
  # 在多人登录同一账号时，是否共用一个 token （为 true 时所有登录共用一个 token, 为 false 时每次登录新建一个 token）
  is-share: true
  # token 风格（默认可取值：uuid、simple-uuid、random-32、random-64、random-128、tik）
  token-style: uuid
  # 是否输出操作日志
  is-log: true

  # SSO-相关配置
  sso-client:
  # SSO-Server 端主机地址
    server-url: http://sa-sso-server.com:9000
  sign:
      # API 接口调用秘钥，确保和服务端一致,sa-token官方文档会给
      secret-key: xxxx
  # 配置Sa-Token单独使用的Redis连接 （此处需要和SSO-Server端连接同一个Redis）
  alone-redis:
    # Redis数据库索引 (默认为0)
    database: 1
    # Redis服务器地址
    host: xxx
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码（默认为空）
    password: xxx
    timeout: 10s
    lettuce:
      pool:
        # 连接池最大连接数
        max-active: 200
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
        # 连接池中的最大空闲连接
        max-idle: 10
        # 连接池中的最小空闲连接
        min-idle: 0
forest:
  # 关闭 forest 请求日志打印
  log-enabled: false

新建Controller作为客户端接口，用于重定向到SSO服务器和接收服务器参数

//前后台分离架构下集成SSO所需的代码 （SSO-Client端）
@RestController
public class H5Controller {

	// 当前是否登录
	@GetMapping("/sso/isLogin")
	public Object isLogin() {
		return SaResult.data(StpUtil.isLogin());
	}


	// 返回SSO认证中心登录地址 
	@GetMapping("/sso/getSsoAuthUrl")
	public SaResult getSsoAuthUrl(String clientLoginUrl) {
		String serverAuthUrl = SaSsoUtil.buildServerAuthUrl(clientLoginUrl, "");
		return SaResult.data(serverAuthUrl);
	}
	
	// 根据ticket进行登录
	@PostMapping("/sso/doLoginByTicket")
	public SaResult doLoginByTicket(String ticket) {
		SaCheckTicketResult ctr = SaSsoClientProcessor.instance.checkTicket(ticket, "/api/sso/doLoginByTicket");
		StpUtil.login(ctr.loginId, ctr.remainSessionTimeout);
		return SaResult.data(StpUtil.getTokenValue());
	}

	// 全局异常拦截 
	@ExceptionHandler
	public SaResult handlerException(Exception e) {
		e.printStackTrace(); 
		return SaResult.error(e.getMessage());
	}	
}

搭建认证中心SSO Server

新建一个springboot项目作为认证中心，本项目后端系统算做一个客户端client，后续引入多个后端系统，也可以按照客户端方式构建

环境配置

<!-- Sa-Token 权限认证，在线文档：https://sa-token.cc -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-spring-boot-starter</artifactId>
    <version>1.40.0</version>
</dependency>
<!-- Sa-Token 插件：整合SSO -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-sso</artifactId>
    <version>1.40.0</version>
</dependency>
<!-- Sa-Token 整合 Redis (使用 jackson 序列化方式) -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-redis-jackson</artifactId>
    <version>1.40.0</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<!-- redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- 除此之外还需要引入mysql数据库的一些依赖，因为要在认证中心实现登录校验 -->

# 端口
server:
    port: 9000
# Sa-Token 配置
sa-token:
    # ------- SSO-模式二相关配置 
    sso-server:
        # Ticket有效期 (单位: 秒)，默认五分钟 
        ticket-timeout: 300
        # 所有允许的授权回调地址
        allow-url: "http://sa-sso-client1/api/sso/login,http://sa-sso-client2/api/sso/login"
    sign:
        # API 接口调用秘钥
        secret-key: xxx
spring:
    datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://xxx/xxx
        username: xxx
        password: xxx
    # Redis配置 （SSO模式一和模式二使用Redis来同步会话）
    redis:
        # Redis数据库索引（默认为0）
        database: 1
        # Redis服务器地址
        host: xxx
        # Redis服务器连接端口
        port: 6379
        # Redis服务器连接密码（默认为空）
        password: xxx
        # 连接超时时间
        timeout: 10s
        lettuce:
            pool:
                # 连接池最大连接数
                max-active: 200
                # 连接池最大阻塞等待时间（使用负值表示没有限制）
                max-wait: -1ms
                # 连接池中的最大空闲连接
                max-idle: 10
                # 连接池中的最小空闲连接
                min-idle: 0
        
forest: 
    # 关闭 forest 请求日志打印
    log-enabled: false

开放认证接口

新建 SsoServerController，用于对外开放接口，先直接拉官方server-demo，在修改

//SSO Server端 Controller
@RestController
public class SsoServerController {

	//处理所有SSO相关请求：拆分式路由

	// SSO-Server：统一认证地址，接受参数：redirect=授权重定向地址
	// 作用: 用户未登录，重定向到登陆页面
	//    ** 已登录，生成Ticket重定向回客户端**（已登录内部是通过redis查看用户id来判断的）
	@RequestMapping("/sso/auth")
	public Object ssoAuth() {
		return SaSsoServerProcessor.instance.ssoAuth();
	}


	// SSO-Server：RestAPI 登录接口，账号密码登录接口，接受参数：name、pwd
	// 作用: 处理登录表单提交，调用doLoginHandle进行验证
	//      验证成功后生成SSO票据并返回给客户端
	@RequestMapping("/sso/doLogin")
	public Object ssoDoLogin() {
		return SaSsoServerProcessor.instance.ssoDoLogin();
	}
	/**
	 * 盐值，混淆密码
	 */
	public static final String SALT = "kk";

	@Resource
	private UserService userService;

	// 配置SSO相关参数 
	@Autowired
	private void configSso(SaSsoServerConfig ssoServer) {
		// 自定义API地址，用于修改统一认证中心的地址
		//SaSsoServerProcessor.instance.ssoServerTemplate.apiName.ssoAuth = "/sso/auth2";

		// 配置：未登录时返回的View
		ssoServer.notLoginView = () -> {
			return new ModelAndView("sa-login.html");
		};
		
		// 配置：登录处理函数  参数:账号密码
		ssoServer.doLoginHandle = (name, pwd) -> {
			// 1. 校验
			if (StringUtils.isAnyBlank(name, pwd)) {
				return SaResult.error("参数为空");
			}
			if (name.length() < 4) {
				return SaResult.error( "账号错误");
			}
			if (pwd.length() < 8) {
				return SaResult.error("密码错误");
			}
			// 2. 加密
			String encryptPassword = DigestUtils.md5DigestAsHex((SALT + pwd).getBytes());
			// 查询用户是否存在
			QueryWrapper<User> queryWrapper = new QueryWrapper<>();
			queryWrapper.eq("userAccount", name);
			queryWrapper.eq("userPassword", encryptPassword);
			User user = userService.getUserInfo(queryWrapper);
			// 用户不存在
			if (user == null) {
				// 登录失败，重定向到 /sso/auth 并携带错误参数
				return "redirect:/sso/auth?error=用户不存在或密码错误";
			}
			// 获取当前请求
			HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
			String device = DeviceUtils.getRequestDevice(request);
			// 使用 Sa-Token 登录，并指定设备，同端登录互斥
			StpUtil.login(user.getId(), device);
			StpUtil.getSession().set("user_login", user);
			return SaResult.ok("登录成功！").setData(StpUtil.getTokenValue());
		};

	}

	// 在 SsoServerController 或全局配置中添加
	@Bean
	public SaServletFilter saServletFilter() {
		return new SaServletFilter()
				.setBeforeAuth(obj -> {
					// 设置响应头防止缓存
					SaHolder.getResponse().setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
					SaHolder.getResponse().setHeader("Pragma", "no-cache");
					SaHolder.getResponse().setHeader("Expires", "0");
				});
	}
}

启动类

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
    System.out.println();
    System.out.println("---------------------- Sa-Token SSO 统一认证中心启动成功 ----------------------");
    System.out.println("配置信息：" + SaSsoManager.getServerConfig());
    System.out.println();
}

跨域处理

配置项 sa-token.sso-server.allow-url=* 意为配置所有允许的Client端授权地址，不在此配置项中的URL将无法单点登录成功

但是，在生产环境中，此配置项绝对不能配置为 * ，否则会有被Ticket劫持的风险

假设攻击者根据模仿我们的授权地址，巧妙的构造一个URL

http://sa-sso-server.com:9000/sso/auth?redirect=https://www.baidu.com/

当不知情的小白被诱导访问了这个URL时，它将被重定向至百度首页，代表着用户身份的Ticket码也显现到了URL之中

防范处理

对redirect参数进行校验，如果其不在指定的URL列表中时，拒绝下放ticket

#SSO服务器端进行配置
sa-token: 
    sso-server: 
        # 配置允许单点登录的 url   
        allow-url: "http://localhost:8101/sso/login"  #配置到详细地址

为什么不直接回传 Token，而是先回传 Ticket，再用 Ticket 去查询对应的账号id？

Token 作为长时间有效的会话凭证，任何时候都不应该直接暴露在 URL 之中（虽然 Token 很安全，但会直接暴露为很多漏洞提供可乘之机）

为了让系统绝对安全，选择先回传 Ticket，再由Ticket获取账号id，而且 Ticket 一次性用完即废，提高安全性。

查看全文

http://www.kler.cn/a/599122.html

Android在kts中简单使用AIDL

Layotto 是一款使用 Golang 开发的应用运行时，旨在帮助开发人员快速构建云原生应用

Uniapp：基于 Vue.js 的高效跨平台开发框架

spring.datasource.filters = stat,wall配置解释

PostgreSQL 触发器

耘想Docker版Linux NAS的安装说明

MAC+PHY 的硬件连接

【重构小程序】基于Tika和Langchain4J进行文件解析和文本切片（二）

使用DeepSeek翻译英文科技论文，以MarkDown格式输出，使用Writage 3.3.1插件转换为Word文件

Android使用RxHttp进行国密4加密解密

git 仓库迁移 git clone --mirror git push --mirror

从零构建大语言模型全栈开发指南：第一部分：数学与理论基础-1.2.1RNN与LSTM的局限性

Java Stream两种list判断字符串是否存在方案

yolo目标检测算法在DJI上的研究分析（大纲）

【蓝桥杯速成】| 10.回溯切割

2025年如何避免使用验证码求解器时被IP封禁

pta 乐子人游戏

意法半导体 (ST) 推出的短距离无线 MCU STM32WBA6----可用于连接工业设备的

练习用Jupyter使用selenium【疑问未解决版】

同端互斥登录

单点登录SSO

架构选型

模式二: URL重定向传播

前后端分离

整体流程

准备工作

搭建客户端

搭建认证中心SSO Server

环境配置

开放认证接口

启动类

跨域处理

相关文章：

`前后端分离`

`整体流程`

`准备工作`

`搭建客户端`