1
CREATE TABLE auth_platforms (
2
    id            INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
3
    code          VARCHAR(32)  NOT NULL COMMENT '平台标识（admin/app/mini/h5）',
4
    name          VARCHAR(64)  NOT NULL COMMENT '平台名称',
5
    login_types   JSON         NOT NULL COMMENT '允许的登录方式',
6
    access_ttl    INT UNSIGNED NOT NULL DEFAULT 14400 COMMENT 'access_token 有效期（秒）',
7
    refresh_ttl   INT UNSIGNED NOT NULL DEFAULT 1209600 COMMENT 'refresh_token 有效期（秒）',
8
    bind_platform TINYINT(1)   NOT NULL DEFAULT 1 COMMENT '绑定平台',
9
    bind_device   TINYINT(1)   NOT NULL DEFAULT 0 COMMENT '绑定设备',
10
    bind_ip       TINYINT(1)   NOT NULL DEFAULT 0 COMMENT '绑定IP',
11
    single_session TINYINT(1)  NOT NULL DEFAULT 0 COMMENT '单端登录',
12
    max_sessions  INT UNSIGNED NOT NULL DEFAULT 0 COMMENT '最大会话数（0=不限）',
13
    allow_register TINYINT(1)  NOT NULL DEFAULT 0 COMMENT '允许注册',
14
    status        TINYINT(1)   NOT NULL DEFAULT 1,
15
    is_del        TINYINT(1)   NOT NULL DEFAULT 0,
16
    created_at    TIMESTAMP    DEFAULT CURRENT_TIMESTAMP,
17
    updated_at    TIMESTAMP    DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
18
    UNIQUE KEY uk_code (code),
19
    KEY idx_status_del (status, is_del)
20
) COMMENT '认证平台配置';

1
admin：access_ttl=4小时，单端登录，禁止注册，绑定平台
2
app：  access_ttl=8小时，最多5个会话，允许注册，绑定设备
3
mini： access_ttl=2小时，不限会话，允许注册，绑定IP

1
class AuthPlatformModel extends BaseModel
2
{
3
    protected $table = 'auth_platforms';
4
    protected $casts = [
5
        'login_types' => 'json',
6
    ];
7
}

1
class AuthPlatformController extends Controller
2
{
3
    public function init(Request $request)
4
    {
5
        return $this->run([AuthPlatformModule::class, 'init'], $request);
6
    }
7

8
    public function list(Request $request)
9
    {
10
        return $this->run([AuthPlatformModule::class, 'list'], $request);
11
    }
12

13
    /** @OperationLog("认证平台新增") @Permission("system_authPlatform_add") */
14
    public function add(Request $request)
15
    {
16
        return $this->run([AuthPlatformModule::class, 'add'], $request);
17
    }
18

19
    /** @OperationLog("认证平台编辑") @Permission("system_authPlatform_edit") */
20
    public function edit(Request $request)
21
    {
22
        return $this->run([AuthPlatformModule::class, 'edit'], $request);
23
    }
24

25
    /** @OperationLog("认证平台删除") @Permission("system_authPlatform_del") */
26
    public function del(Request $request)
27
    {
28
        return $this->run([AuthPlatformModule::class, 'del'], $request);
29
    }
30

31
    /** @OperationLog("认证平台状态变更") @Permission("system_authPlatform_status") */
32
    public function status(Request $request)
33
    {
34
        return $this->run([AuthPlatformModule::class, 'status'], $request);
35
    }
36
}

1
class AuthPlatformValidate
2
{
3
    public static function add(): array
4
    {
5
        return [
6
            'code'           => v::regex('/^[a-z][a-z0-9_]{1,48}$/')->setName('平台标识'),
7
            'name'           => v::length(1, 100)->setName('平台名称'),
8
            'login_types'    => v::arrayType()->each(
9
                v::stringType()->in(['password', 'email', 'phone'])
10
            )->setName('登录方式'),
11
            'access_ttl'     => v::intVal()->between(60, 2592000)->setName('access_token有效期'),
12
            'refresh_ttl'    => v::intVal()->between(60, 31536000)->setName('refresh_token有效期'),
13
            'bind_platform'  => v::intVal()->in([1, 2])->setName('绑定平台'),
14
            'bind_device'    => v::intVal()->in([1, 2])->setName('绑定设备'),
15
            'bind_ip'        => v::intVal()->in([1, 2])->setName('绑定IP'),
16
            'single_session' => v::intVal()->in([1, 2])->setName('单端登录'),
17
            'max_sessions'   => v::intVal()->between(0, 100)->setName('最大会话数'),
18
            'allow_register' => v::intVal()->in([1, 2])->setName('允许注册'),
19
        ];
20
    }
21

22
    public static function edit(): array
23
    {
24
        return [
25
            'id'   => v::intVal()->setName('ID'),
26
            // ... 其余字段同 add，但不含 code（code 不可修改）
27
        ];
28
    }
29
}

1
class AuthPlatformModule extends BaseModule
2
{
3
    protected AuthPlatformDep $authPlatformDep;
4
    protected DictService $dictService;
5

6
    public function __construct()
7
    {
8
        $this->authPlatformDep = $this->dep(AuthPlatformDep::class);
9
        $this->dictService = $this->svc(DictService::class);
10
    }
11

12
    /**
13
     * 初始化字典（前端下拉选项全部从这里拿）
14
     */
15
    public function init($request): array
16
    {
17
        $data['dict'] = $this->dictService
18
            ->setCommonStatusArr()
19
            ->setAuthPlatformLoginTypeArr()
20
            ->getDict();
21
        return self::success($data);
22
    }
23

24
    /**
25
     * 新增平台
26
     */
27
    public function add($request): array
28
    {
29
        $param = $this->validate($request, AuthPlatformValidate::add());
30

31
        // 唯一性校验
32
        self::throwIf(
33
            $this->authPlatformDep->existsByCode($param['code']),
34
            "平台标识 [{$param['code']}] 已存在"
35
        );
36

37
        $this->authPlatformDep->addPlatform([
38
            'code'           => $param['code'],
39
            'name'           => $param['name'],
40
            'login_types'    => \json_encode($param['login_types']),
41
            'access_ttl'     => (int)$param['access_ttl'],
42
            'refresh_ttl'    => (int)$param['refresh_ttl'],
43
            'bind_platform'  => (int)$param['bind_platform'],
44
            'bind_device'    => (int)$param['bind_device'],
45
            'bind_ip'        => (int)$param['bind_ip'],
46
            'single_session' => (int)$param['single_session'],
47
            'max_sessions'   => (int)$param['max_sessions'],
48
            'allow_register' => (int)$param['allow_register'],
49
            'status'         => CommonEnum::YES,
50
            'is_del'         => CommonEnum::NO,
51
        ]);
52

53
        return self::success();
54
    }
55
}

1
class AuthPlatformDep extends BaseDep
2
{
3
    const CACHE_PREFIX = 'auth_platform_';
4
    const CACHE_ALL    = 'auth_platform_all';
5

6
    protected function createModel(): Model
7
    {
8
        return new AuthPlatformModel();
9
    }
10

11
    /**
12
     * 根据 code 获取启用的平台配置（永久缓存，写时清除）
13
     */
14
    public function getByCode(string $code): ?array
15
    {
16
        $cacheKey = self::CACHE_PREFIX . $code;
17
        $cached = Cache::get($cacheKey);
18
        if ($cached !== null) {
19
            return $cached ?: null;  // false 表示"确认不存在"
20
        }
21

22
        $row = $this->model
23
            ->where('code', $code)
24
            ->where('status', CommonEnum::YES)
25
            ->where('is_del', CommonEnum::NO)
26
            ->first();
27

28
        if (!$row) {
29
            // 缓存空值，防止缓存穿透
30
            Cache::set($cacheKey, false);
31
            return null;
32
        }
33

34
        $data = $row->toArray();
35
        Cache::set($cacheKey, $data);  // 永久缓存，不设 TTL
36
        return $data;
37
    }
38
}

1
// 新增平台
2
public function addPlatform(array $data): int
3
{
4
    $id = $this->model->insertGetId($data);
5
    $this->clearCache($data['code'] ?? '');
6
    return $id;
7
}
8

9
// 更新平台（需要清除新旧两个 code 的缓存）
10
public function updateById(int $id, array $data, ?string $oldCode = null): bool
11
{
12
    $count = $this->model->where('id', $id)->where('is_del', CommonEnum::NO)->update($data);
13
    if ($count > 0) {
14
        if ($oldCode) {
15
            $this->clearCache($oldCode);
16
        }
17
        if (!empty($data['code'])) {
18
            $this->clearCache($data['code']);
19
        }
20
    }
21
    return $count > 0;
22
}
23

24
// 删除平台（软删除，清除所有被删平台的缓存）
25
public function deleteByIds($ids): bool
26
{
27
    $ids = \is_array($ids) ? $ids : [$ids];
28
    $rows = $this->model->whereIn('id', $ids)->where('is_del', CommonEnum::NO)->get(['code']);
29
    $count = $this->model->whereIn('id', $ids)->update(['is_del' => CommonEnum::YES]);
30
    if ($count > 0) {
31
        foreach ($rows as $r) {
32
            $this->clearCache($r->code);
33
        }
34
    }
35
    return $count > 0;
36
}

1
private function clearCache(string $code = ''): void
2
{
3
    // 清 Redis 缓存
4
    Cache::delete(self::CACHE_ALL);
5
    Cache::delete(self::CACHE_ALL . '_map');
6
    if ($code) {
7
        Cache::delete(self::CACHE_PREFIX . $code);
8
    }
9
    // 清当前进程内存缓存
10
    AuthPlatformService::flushMemCache();
11
}

1
┌─────────────────────────────────────────────────────┐
2
│                    API 请求                          │
3
└──────────────────────┬──────────────────────────────┘
4
                       ▼
5
┌─────────────────────────────────────────────────────┐
6
│  L1: 进程内存缓存（~0ms）                             │
7
│  PHP 静态变量，TTL 60秒                               │
8
│  Webman 常驻进程，内存不会被释放                        │
9
└──────────────────────┬──────────────────────────────┘
10
                       │ 未命中 / 过期
11
                       ▼
12
┌─────────────────────────────────────────────────────┐
13
│  L2: Redis 缓存（0.1-0.5ms）                         │
14
│  永久缓存，写操作时主动清除                             │
15
│  cache 连接，独立于 token 连接                         │
16
└──────────────────────┬──────────────────────────────┘
17
                       │ 未命中
18
                       ▼
19
┌─────────────────────────────────────────────────────┐
20
│  L3: MySQL（1-5ms）                                  │
21
│  auth_platforms 表，查完回写 L2                        │
22
└─────────────────────────────────────────────────────┘

1
PHP-FPM:
2
  请求1 → 进程A（创建变量 → 处理 → 销毁变量 → 进程回收）
3
  请求2 → 进程B（创建变量 → 处理 → 销毁变量 → 进程回收）
4
  每次都从零开始
5

6
Webman:
7
  Worker进程A（启动 → 处理请求1 → 处理请求2 → ... → 处理请求N）
8
  静态变量在请求1写入后，请求2直接读取，零开销

1
class AuthPlatformService
2
{
3
    private static ?AuthPlatformDep $dep = null;
4

5
    /** 进程级内存缓存：code → 平台数据 */
6
    private static array $memPlatform = [];
7
    /** 所有启用平台 code 列表 */
8
    private static ?array $memCodes = null;
9
    /** code→name 映射 */
10
    private static ?array $memMap = null;
11
    /** 缓存写入时间戳 */
12
    private static int $memPlatformAt = 0;
13
    private static int $memCodesAt = 0;
14
    private static int $memMapAt = 0;
15

16
    private const MEM_TTL = 60; // 60秒过期
17

18
    private static function isExpired(int $timestamp): bool
19
    {
20
        return (\time() - $timestamp) > self::MEM_TTL;
21
    }
22
}

1
public static function getPlatform(string $code): array
2
{
3
    // L1: 进程内存
4
    if (isset(self::$memPlatform[$code]) && !self::isExpired(self::$memPlatformAt)) {
5
        return self::$memPlatform[$code];
6
    }
7

8
    // L2+L3: Redis → DB（由 Dep 层处理）
9
    $platform = self::dep()->getByCode($code);
10
    if (!$platform) {
11
        throw new BusinessException("平台 [{$code}] 未配置或已禁用，拒绝访问", 401);
12
    }
13

14
    // 回写内存
15
    self::$memPlatform[$code] = $platform;
16
    self::$memPlatformAt = \time();
17

18
    return $platform;
19
}

1
/**
2
 * 获取平台的完整安全策略
3
 */
4
public static function getAuthPolicy(string $code): array
5
{
6
    $p = self::getPlatform($code);
7
    return [
8
        'bind_platform'              => $p['bind_platform'] === CommonEnum::YES,
9
        'bind_device'                => $p['bind_device'] === CommonEnum::YES,
10
        'bind_ip'                    => $p['bind_ip'] === CommonEnum::YES,
11
        'single_session_per_platform' => $p['single_session'] === CommonEnum::YES,
12
        'max_sessions'               => (int)$p['max_sessions'],
13
        'allow_register'             => $p['allow_register'] === CommonEnum::YES,
14
    ];
15
}
16

17
/**
18
 * 获取平台的 access_token TTL
19
 */
20
public static function getAccessTtl(string $code): int
21
{
22
    return (int)self::getPlatform($code)['access_ttl'];
23
}
24

25
/**
26
 * 获取平台的 refresh_token TTL
27
 */
28
public static function getRefreshTtl(string $code): int
29
{
30
    return (int)self::getPlatform($code)['refresh_ttl'];
31
}
32

33
/**
34
 * 获取平台允许的登录方式
35
 */
36
public static function getLoginTypes(string $code): array
37
{
38
    $p = self::getPlatform($code);
39
    $types = $p['login_types'];
40
    return \is_array($types) ? $types : \json_decode($types, true) ?? [];
41
}
42

43
/**
44
 * 平台是否允许注册
45
 */
46
public static function isRegisterEnabled(string $code): bool
47
{
48
    return self::getPlatform($code)['allow_register'] === CommonEnum::YES;
49
}
50

51
/**
52
 * 校验平台是否合法并返回安全策略（合并调用）
53
 * 用于 CheckToken 中间件，一次查询搞定
54
 */
55
public static function validateAndGetPolicy(string $code): ?array
56
{
57
    if (!\in_array($code, self::getAllowedPlatforms(), true)) {
58
        return null;
59
    }
60
    return self::getAuthPolicy($code);
61
}

1
Worker A: 修改平台配置 → 清 Redis → 清自己内存 ✓
2
Worker B: 内存缓存还是旧的 ✗（最多 60 秒后过期）
3
Worker C: 内存缓存还是旧的 ✗（最多 60 秒后过期）
4
Worker D: 内存缓存还是旧的 ✗（最多 60 秒后过期）

1
/**
2
 * 清除当前进程的内存缓存（写操作后调用）
3
 */
4
public static function flushMemCache(): void
5
{
6
    self::$memPlatform = [];
7
    self::$memCodes = null;
8
    self::$memMap = null;
9
    self::$memPlatformAt = 0;
10
    self::$memCodesAt = 0;
11
    self::$memMapAt = 0;
12
}

1
class TokenService
2
{
3
    /**
4
     * 生成随机 Token
5
     */
6
    public static function makeToken(int $bytes = 32): string
7
    {
8
        return bin2hex(random_bytes($bytes));
9
    }
10

11
    /**
12
     * Token 哈希（加 pepper 防彩虹表）
13
     */
14
    public static function hashToken(string $token): string
15
    {
16
        $pepper = (string) config('app.token_pepper', '');
17
        if ($pepper === '' || $pepper === 'change_me_to_long_random') {
18
            throw new \RuntimeException('TOKEN_PEPPER 未配置或不安全');
19
        }
20
        return hash('sha256', $token . '|' . $pepper);
21
    }
22

23
    /**
24
     * 生成 Token 对（按平台配置不同的 TTL）
25
     */
26
    public static function generateTokenPair(string $platform): array
27
    {
28
        $now = Carbon::now();
29
        $accessTtl = AuthPlatformService::getAccessTtl($platform);
30
        $refreshTtl = AuthPlatformService::getRefreshTtl($platform);
31

32
        $accessToken = self::makeToken(32);    // 64 字符 hex
33
        $refreshToken = self::makeToken(64);   // 128 字符 hex
34

35
        return [
36
            'access_token'       => $accessToken,
37
            'refresh_token'      => $refreshToken,
38
            'access_token_hash'  => self::hashToken($accessToken),
39
            'refresh_token_hash' => self::hashToken($refreshToken),
40
            'access_expires'     => $now->copy()->addSeconds($accessTtl),
41
            'refresh_expires'    => $now->copy()->addSeconds($refreshTtl),
42
            'access_ttl'         => $accessTtl,
43
            'refresh_ttl'        => $refreshTtl,
44
            'now'                => $now,
45
        ];
46
    }
47
}

1
key:   {access_token_hash}
2
value: userId|expiresAt|ip|platform|deviceId|sessionId
3
TTL:   1800（30分钟，每次请求续期）

1
// JSON 方案：序列化/反序列化开销
2
$session = json_decode(Redis::get($key), true);
3
// 每次请求都要 json_decode，CPU 开销不小
4

5
// 管道分隔方案：explode 比 json_decode 快 5-10 倍
6
$parts = explode('|', $cached);
7
$session = [
8
    'user_id'    => $parts[0],
9
    'expires_at' => $parts[1],
10
    'ip'         => $parts[2],
11
    'platform'   => $parts[3],
12
    'device_id'  => $parts[4] ?? '',
13
    'id'         => $parts[5] ?? 0,
14
];

1
请求进来 → CheckToken
2
  │
3
  ├─ 1. 解析 Bearer Token → SHA256(token + pepper) → hash
4
  │
5
  ├─ 2. resolveSession(hash)
6
  │     ├─ Redis token连接 GET {hash}
7
  │     │   命中 → explode('|') 解析 → 返回会话
8
  │     │   未命中 → 查 DB user_sessions 表
9
  │     │            → 回写 Redis（管道分隔，TTL 30分钟）
10
  │     └─ 返回: userId | expiresAt | ip | platform | deviceId | sessionId
11
  │
12
  ├─ 3. 检查 access_token 是否过期
13
  │     └─ Carbon::parse(expires_at)->isPast() → 过期则删 Redis 返回 401
14
  │
15
  ├─ 4. 平台校验
16
  │     ├─ 请求头必须携带 platform（强制，无默认值）
17
  │     └─ AuthPlatformService::isValidPlatform(platform)
18
  │        └─ 内存缓存命中(~0ms) ← 60秒内不查Redis
19
  │
20
  ├─ 5. 安全策略校验
21
  │     ├─ AuthPlatformService::getAuthPolicy(会话中的 platform)
22
  │     │   └─ 内存缓存命中(~0ms) ← getPlatform 已缓存
23
  │     ├─ bind_platform: 会话平台 vs 请求头平台
24
  │     ├─ bind_device: 会话设备ID vs 请求头 device-id
25
  │     └─ bind_ip: 会话IP vs 当前请求IP
26
  │
27
  ├─ 6. 挂载请求信息
28
  │     ├─ $request->userId = 用户ID
29
  │     ├─ $request->sessionId = 会话ID
30
  │     └─ $request->platform = 平台标识
31
  │
32
  ├─ 7. 单端登录裁决（如果开启）
33
  │     └─ checkSingleSession()
34
  │        ├─ Redis GET cur_sess:{platform}:{userId}
35
  │        ├─ 指针存在且匹配 → 通过
36
  │        ├─ 指针不存在 → 查DB重建指针
37
  │        ├─ 指针不匹配 → 验证指针有效性
38
  │        └─ 最终不匹配 → 删 Redis，返回"账号已在其他设备登录"
39
  │
40
  └─ 8. 续期 Redis → EXPIRE {hash} 30分钟
41
        └─ 用户活跃期间，会话缓存永不过期

1
private function resolveSession(string $redisKey, string $tokenHash): ?array
2
{
3
    // 优先从 Redis 读取
4
    $cached = Redis::connection('token')->get($redisKey);
5

6
    if ($cached) {
7
        $parts = explode('|', $cached);
8
        if (\count($parts) >= 4) {
9
            return [
10
                'user_id'    => $parts[0],
11
                'expires_at' => $parts[1],
12
                'ip'         => $parts[2],
13
                'platform'   => $parts[3],
14
                'device_id'  => $parts[4] ?? '',
15
                'id'         => $parts[5] ?? 0,
16
            ];
17
        }
18
    }
19

20
    // Redis 未命中，查 DB
21
    $sessionDep = new UserSessionsDep();
22
    $row = $sessionDep->findValidByAccessHash($tokenHash);
23
    if (!$row) {
24
        return null;
25
    }
26

27
    $session = \is_object($row) ? $row->toArray() : (array)$row;
28

29
    // 回写 Redis（管道分隔，TTL 30分钟）
30
    $value = implode('|', [
31
        $session['user_id'],
32
        $session['expires_at'],
33
        $session['ip'] ?? '',
34
        $session['platform'] ?? '',
35
        $session['device_id'] ?? '',
36
        $session['id'],
37
    ]);
38
    Redis::connection('token')->set($redisKey, $value, CacheTTLEnum::TOKEN_SESSION);
39

40
    return $session;
41
}

1
// 5.1 绑定平台：防止 Token 跨平台使用
2
if (!empty($policy['bind_platform'])) {
3
    if (strtolower($session['platform']) !== strtolower($currentPlatform)) {
4
        return json(['code' => ErrorCodeEnum::UNAUTHORIZED, 'msg' => '平台不匹配']);
5
    }
6
}
7

8
// 5.2 绑定设备：防止 Token 在其他设备使用
9
if (!empty($policy['bind_device']) && !empty($session['device_id'])) {
10
    $currentDevice = $request->header('device-id');
11
    if (!$currentDevice || $currentDevice !== $session['device_id']) {
12
        return json(['code' => ErrorCodeEnum::UNAUTHORIZED, 'msg' => '设备变更，请重新登录']);
13
    }
14
}
15

16
// 5.3 绑定 IP：最严格模式，IP 变动直接踢下线
17
if (!empty($policy['bind_ip'])) {
18
    if ($session['ip'] !== $request->getRealIp()) {
19
        Redis::connection('token')->del($redisKey);  // 主动删除缓存
20
        return json(['code' => ErrorCodeEnum::UNAUTHORIZED, 'msg' => 'IP地址变动']);
21
    }
22
}

1
private function checkSingleSession(array $session, string $redisKey): ?Response
2
{
3
    $curSessKey = "cur_sess:" . strtolower(trim($session['platform']))
4
                . ":{$session['user_id']}";
5
    $allowedSessionId = Redis::connection('token')->get($curSessKey);
6

7
    // 情况1：指针不存在，从 DB 重建
8
    if (!$allowedSessionId) {
9
        $latest = (new UserSessionsDep())
10
            ->findLatestActiveByUserPlatform($session['user_id'], $session['platform']);
11
        if ($latest) {
12
            $allowedSessionId = $latest->id;
13
            Redis::connection('token')->set(
14
                $curSessKey, $allowedSessionId, CacheTTLEnum::SINGLE_SESSION_POINTER
15
            );
16
        }
17
    }
18
    // 情况2：指针存在但不匹配，验证指针有效性
19
    elseif ((int)$allowedSessionId !== (int)$session['id']) {
20
        $latest = (new UserSessionsDep())
21
            ->findLatestActiveByUserPlatform($session['user_id'], $session['platform']);
22
        if ($latest && $latest->id != $allowedSessionId) {
23
            // 指针指向的会话已失效，更新指针
24
            $allowedSessionId = $latest->id;
25
            Redis::connection('token')->set(
26
                $curSessKey, $allowedSessionId, CacheTTLEnum::SINGLE_SESSION_POINTER
27
            );
28
        } elseif (!$latest) {
29
            $allowedSessionId = null;
30
        }
31
    }
32
    // 情况3：指针匹配 → 直接通过（最常见路径，不查 DB）
33

34
    // 最终裁决
35
    if ($allowedSessionId && (int)$allowedSessionId !== (int)$session['id']) {
36
        Redis::connection('token')->del($redisKey);
37
        return json([
38
            'code' => ErrorCodeEnum::UNAUTHORIZED,
39
            'msg'  => '账号已在其他设备登录',
40
        ]);
41
    }
42

43
    return null;  // 通过
44
}

1
if (!empty($policy['single_session_per_platform'])) {
2
    // 查出该用户在此平台的所有活跃会话
3
    $oldSessions = $this->userSessionsDep->listActiveByUserPlatform($userId, $platformHeader);
4

5
    // 逐个删除 Redis 缓存
6
    foreach ($oldSessions as $old) {
7
        Redis::connection('token')->del($old->access_token_hash);
8
    }
9

10
    // 批量撤销 DB 会话
11
    $this->userSessionsDep->revokeByUserPlatform($userId, $platformHeader);
12
}

1
elseif ($policy['max_sessions'] > 0) {
2
    $activeSessions = $this->userSessionsDep->listActiveByUserPlatform($userId, $platformHeader);
3

4
    // 计算需要淘汰的数量（当前活跃数 - 上限 + 1（给新会话腾位置））
5
    $overCount = $activeSessions->count() - $policy['max_sessions'] + 1;
6

7
    if ($overCount > 0) {
8
        // 按 ID 升序排列，取最早的 N 个淘汰
9
        $toRevoke = $activeSessions->sortBy('id')->take($overCount);
10
        foreach ($toRevoke as $old) {
11
            Redis::connection('token')->del($old->access_token_hash);
12
            $this->userSessionsDep->revoke($old->id);
13
        }
14
    }
15
}

1
overCount = 5 - 5 + 1 = 1
2
淘汰最早的 1 个会话 → 剩余 4 个 + 新建 1 个 = 5 个

1
if (!empty($policy['single_session_per_platform'])) {
2
    // 单端登录逻辑
3
} elseif ($policy['max_sessions'] > 0) {
4
    // 多会话上限逻辑
5
}

1
private function updateSessionPointer(int $userId, string $platform, int $sessionId): void
2
{
3
    $key = "cur_sess:" . strtolower(trim($platform)) . ":{$userId}";
4
    Redis::connection('token')->set($key, $sessionId, CacheTTLEnum::SINGLE_SESSION_POINTER);
5
}

1
private function clearSessionPointerIfMatches(int $userId, string $platform, int $sessionId): void
2
{
3
    if (!$platform) return;
4
    $key = "cur_sess:" . strtolower(trim($platform)) . ":{$userId}";
5
    $currentPtr = Redis::connection('token')->get($key);
6
    // 只有指针指向当前会话时才删除，避免误删新会话的指针
7
    if ($currentPtr && (int)$currentPtr === (int)$sessionId) {
8
        Redis::connection('token')->del($key);
9
    }
10
}

1
public function getLoginConfig(): array
2
{
3
    $platform = request()->header('platform', '');
4
    self::throwIf(!$platform, '缺少平台标识');
5

6
    // 从 auth_platforms 表动态读取该平台允许的登录方式
7
    $allowedTypes = AuthPlatformService::getLoginTypes($platform);
8

9
    // 和系统定义的登录方式取交集，返回给前端
10
    $filtered = [];
11
    foreach (SystemEnum::$loginTypeArr as $key => $label) {
12
        if (\in_array($key, $allowedTypes, true)) {
13
            $filtered[] = ['label' => $label, 'value' => $key];
14
        }
15
    }
16
    return self::success(['login_type_arr' => $filtered]);
17
}

1
private function loginByCode(array $param, string $loginType, $request): array
2
{
3
    // 1. 验证码校验
4
    if ($loginType === SystemEnum::LOGIN_TYPE_EMAIL) {
5
        $cacheKey = 'email_code_' . md5($param['login_account']);
6
    } else {
7
        $cacheKey = 'phone_code_' . md5($param['login_account']);
8
    }
9

10
    $code = Cache::get($cacheKey);
11
    if (!$code || $code != $param['code']) {
12
        return ['error' => '验证码错误或已失效', 'user' => null];
13
    }
14
    Cache::delete($cacheKey);  // 验证码一次性使用
15

16
    // 2. 查找用户
17
    $user = $loginType === SystemEnum::LOGIN_TYPE_EMAIL
18
        ? $this->usersDep->findByEmail($param['login_account'])
19
        : $this->usersDep->findByPhone($param['login_account']);
20

21
    // 3. 自动注册（如果平台允许）
22
    if (!$user) {
23
        $platform = $request->header('platform');
24
        if (!AuthPlatformService::isRegisterEnabled($platform)) {
25
            return ['error' => '暂未开放注册', 'user' => null];
26
        }
27
        $user = $this->autoRegister($param['login_account'], $loginType);
28
    }
29

30
    return ['error' => false, 'user' => $user];
31
}