一个欲儿的博客

造梦西游3再续天庭存档修改

Sat, 27 Jun 2026 15:28:10 +0800

《再续天庭1.1》的存档解密逻辑主要经历了四个步骤：

第一步，程序读取指定的加密存档文件，并去除其中的换行和空格，然后使用自定义的 Base64 字符表“zYxWvUtSrQpOnMlKjIhGfEdCbAaBcDeFgHiJkLmNoPqRsTuVwXyZ1234567890+/=”对文本进行变体 Base64 解码，将其还原为原始的字节数组；

第二步，程序对该字节数组中的每一个字节进行异或（XOR）运算，固定的异或密钥为十进制的 90（即十六进制的 0x5A），这一步利用了异或运算的自反性来逆转混淆；

第三步，程序进入一个最多执行 10 次的循环，尝试使用 Zlib 库进行多层解压缩，期间会兼顾处理包含或不包含标准标头的压缩流数据，直到无法继续解压、触发异常时自动跳出循环；

第四步，程序进行 AMF3 协议的数据反序列化解析，首先校验第一个字节是否为数字 6（代表字符串对象），验证通过后通过特定的位移运算读取紧随其后的 AMF3 变长整数（U29）以确定 XML 字符串的实际长度，将其右移 1 位得到真正的长度值，并根据该长度截取并使用 UTF-8 编码解码出 XML 明文，最终利用 minidom 库对 XML 进行美化排版并保存为以 .xml 结尾的文本文件。

附上python代码

import os
import zlib
import xml.dom.minidom

# 完美对齐解密出来的自定义 Base64 字符表
CUSTOM_ALPHABET = "zYxWvUtSrQpOnMlKjIhGfEdCbAaBcDeFgHiJkLmNoPqRsTuVwXyZ1234567890+/="
XOR_KEY = 90  # 0x5A

def custom_b64decode(s: str) -> bytearray:
    """变体 Base64 解码逻辑 (函数 o)"""
    s = s.strip().replace("\r", "").replace("\n", "").replace(" ", "")
    data = bytearray()
    for i in range(0, len(s), 4):
        chunk = s[i:i+4]
        c = [CUSTOM_ALPHABET.index(char) if char in CUSTOM_ALPHABET else 64 for char in chunk]
        while len(c) < 4:
            c.append(64)
        b = (c[0] << 2) | ((c[1] & 48) >> 4)
        d = ((c[1] & 15) << 4) | ((c[2] & 60) >> 2)
        g = ((c[2] & 3) << 6) | c[3]
        data.append(b)
        if c[2] != 64: data.append(d)
        if c[3] != 64: data.append(g)
    return data

def custom_b64encode(g: bytearray) -> str:
    """变体 Base64 编码逻辑 (函数 p)"""
    a = ""
    for b in range(0, len(g), 3):
        c = min(3, len(g) - b)
        d = g[b]
        e = g[b + 1] if c > 1 else 0
        f = g[b + 2] if c > 2 else 0
        h = (d & 252) >> 2
        i = (d & 3) << 4 | (e & 240) >> 4
        j = (e & 15) << 2 | (f & 192) >> 6
        k = f & 63
        a += CUSTOM_ALPHABET[h] + CUSTOM_ALPHABET[i]
        a += CUSTOM_ALPHABET[j] if c > 1 else CUSTOM_ALPHABET[64]
        a += CUSTOM_ALPHABET[k] if c > 2 else CUSTOM_ALPHABET[64]
    return a

def read_amf3_integer(data: bytearray, pos: int):
    """AMF3 变长整数 (U29) 读取逻辑 (函数 m)"""
    result = 0
    for i in range(4):
        b = data[pos]
        pos += 1
        if i < 3:
            result = (result << 7) | (b & 127)
            if (b & 128) == 0: break
        else:
            result = (result << 8) | b
    return result, pos

def write_amf3_integer(c: int) -> bytearray:
    """AMF3 变长整数 (U29) 写入逻辑 (函数 n)"""
    a = []
    if c < 128:
        a.push(c) if hasattr(a, 'push') else a.append(c)
    elif c < 16384:
        a.append(c >> 7 & 127 | 128)
        a.append(c & 127)
    elif c < 2097152:
        a.append(c >> 14 & 127 | 128)
        a.append(c >> 7 & 127 | 128)
        a.append(c & 127)
    else:
        a.append(c >> 22 & 127 | 128)
        a.append(c >> 15 & 127 | 128)
        a.append(c >> 8 & 127 | 128)
        a.append(c & 255)
    return bytearray(a)

def format_xml(xml_str: str) -> str:
    """对 XML 进行美化排版"""
    try:
        dom = xml.dom.minidom.parseString(xml_str)
        return dom.toprettyxml(indent="    ")
    except:
        return xml_str

def compress_xml(xml_str: str) -> str:
    """去除 XML 格式化引入的换行和缩进，还原紧凑字符串"""
    lines = [line.strip() for line in xml_str.splitlines() if line.strip()]
    return "".join(lines)

def cmd_decrypt():
    path = input("\n请输入要解密的存档路径 (如 2.sav): ").strip().strip('"')
    if not os.path.exists(path):
        print("[-] 错误：找不到指定文件。")
        return
    
    try:
        with open(path, "r", encoding="utf-8") as f:
            raw_content = f.read()

        # 1. Base64 还原
        bytes_data = custom_b64decode(raw_content)
        # 2. XOR 90 解密
        for i in range(len(bytes_data)): bytes_data[i] ^= XOR_KEY
        # 3. 多层 Zlib 解压
        for _ in range(10):
            try:
                try: bytes_data = zlib.decompress(bytes_data, -zlib.MAX_WBITS)
                except zlib.error: bytes_data = zlib.decompress(bytes_data)
            except zlib.error: break

        # 4. AMF3 解析
        if bytes_data[0] != 6:
            print("[-] 校验失败：该文件不是合法的 AMF3 存档数据。")
            return
        amf3_value, next_pos = read_amf3_integer(bytes_data, 1)
        str_len = amf3_value >> 1
        xml_bytes = bytes_data[next_pos : next_pos + str_len]
        xml_text = xml_bytes.decode('utf-8')

        # 美化排版并保存
        pretty_xml = format_xml(xml_text)
        out_path = path + ".xml"
        with open(out_path, "w", encoding="utf-8") as out_f:
            out_f.write(pretty_xml)
            
        print(f"[+] 解密成功！明文已格式化保存至: {out_path}")
        print("    你可以直接用记事本打开修改它。")
    except Exception as e:
        print(f"[-] 解密过程中发生异常: {e}")

def cmd_encrypt():
    path = input("\n请输入修改后的 XML 明文路径 (如 2.sav.xml): ").strip().strip('"')
    if not os.path.exists(path):
        print("[-] 错误：找不到指定文件。")
        return
        
    try:
        with open(path, "r", encoding="utf-8") as f:
            xml_content = f.read()

        # 压缩掉美化排版的空格和换行
        clean_xml = compress_xml(xml_content)
        xml_bytes = clean_xml.encode('utf-8')

        # 1. AMF3 序列化打包 (函数 l)
        amf3_len_code = (len(xml_bytes) << 1) | 1
        amf3_len_bytes = write_amf3_integer(amf3_len_code)
        
        amf3_packet = bytearray([6]) + amf3_len_bytes + xml_bytes
        
        # 2. Zlib 压缩
        compressed = zlib.compress(amf3_packet)
        compressed_bytes = bytearray(compressed)

        # 3. XOR 90 加密
        for i in range(len(compressed_bytes)): compressed_bytes[i] ^= XOR_KEY

        # 4. 变体 Base64 编码
        final_string = custom_b64encode(compressed_bytes)

        # 保存为新存档
        out_path = path.replace(".xml", "") if path.endswith(".xml") else path + ".sav"
        if out_path == path: out_path += ".new"
            
        with open(out_path, "w", encoding="utf-8") as out_f:
            out_f.write(final_string)
            
        print(f"[+] 加密成功！新存档已打包输出至: {out_path}")
        print("    你可以将此文件改回游戏要求的名字放回存档目录。")
    except Exception as e:
        print(f"[-] 加密过程中发生异常: {e}")

def main():
    print("=" * 45)
    print("   《再续天庭1.1》存档算法逆向破解工具")
    print("=" * 45)
    while True:
        print("\n[可用指令]  1: 加密打包存档  2: 解密分析存档  0: 退出")
        choice = input("请输入指令数字: ").strip()
        if choice == "1":
            cmd_encrypt()
        elif choice == "2":
            cmd_decrypt()
        elif choice == "0":
            print("退出程序。")
            break
        else:
            print("[-] 无效指令，请重新输入。")

if __name__ == "__main__":
    main()

造梦西游3再续天庭CE之旅

Tue, 23 Jun 2026 00:04:44 +0800

一、常识基础

在 Flash 虚拟机中，为了快速区分一个 4 字节（32位）的内存数据到底是一个对象指针还是一个普通整数，它会利用整型数值的低 3 位（Bit）来做“类型标记”。

对于游戏中的普通整数（int / uint 类型），Flash 的规则是：将真实的数值向左移动 3 位（相当于乘以 8），然后在空出来的低 3 位里填入标记代码 110（十进制的 6）。

这就诞生了 Flash 游戏修改的黄金公式：

内存实际值 = 游戏显示值 × 8 + 6

二、无限积分

点开右上角大转盘，宠物分类，看到子鼠了吗？13000积分经过公式换算 13000 x 8 + 6 = 104006，因此ce载入进程搜索4字节准确数值 104006

出来的数据不会很多，直接全部改为-50000积分，即买子鼠还倒给玩家50000，经过公式换算-50000 x 8 + 6 = -399994

其中如果你的ce数值那一栏不是负数，是一串非常大的数据，请右键然后选中显示带符号的

然后此时，返回游戏，点击时装，再点击宠物，就会看到子鼠的购买价格变成负数了，点击购买即可

mac 系统下的短语板

Mon, 22 Jun 2026 20:14:40 +0800

一、环境部署

1.桌面新建snippet-panel 文件夹

2.首次需要创建虚拟环境和依赖

cd ~/Desktop/snippet-panel
python3 -m venv venv
source venv/bin/activate
pip install PyQt6 pyperclip

之后只需要

cd ~/Desktop/snippet-panel
source venv/bin/activate
python3 app.py

二、mac快捷启动

桌面新建start_snippet_panel.command

#!/bin/bash

cd ~/Desktop/snippet-panel

source venv/bin/activate

mkdir -p log

nohup python3 app.py >log/app.log 2>&1 &

之后每次启动，只需要双击该脚本即可。

三、代码

app.py

import sys
import json
import os
import pyperclip
import ctypes
import ctypes.util

from PyQt6.QtWidgets import (
QApplication,
QWidget,
QListWidget,
QListWidgetItem,
QVBoxLayout,
QPushButton,
QHBoxLayout,
QLineEdit,
QLabel,
QDialog,
QTextEdit,
QDialogButtonBox,
QMenu,
)
from PyQt6.QtCore import Qt, QSize, QEvent, pyqtSignal, QObject, QPoint, QTimer
from PyQt6.QtGui import QPainter, QFontMetrics, QAction


APP_DIR = os.path.expanduser("./data")
os.makedirs(APP_DIR, exist_ok=True)
DATA_FILE = os.path.join(APP_DIR, "data.json")


def load_data():
if not os.path.exists(DATA_FILE):
return []
try:
with open(DATA_FILE, "r", encoding="utf-8") as f:
return json.load(f)
except:
return []


def save_data(data):
with open(DATA_FILE, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)


STYLE_SHEET = """
QWidget {
    background-color: #eef0f7;
    font-family: "PingFang SC", "Microsoft YaHei", sans-serif;
    font-size: 14px;
    color: #1f2329;
}

#titleLabel {
    font-size: 18px;
    font-weight: 600;
    color: #1f2329;
}

#searchBox {
    background-color: #ffffff;
    border: 1px solid #e3e6ee;
    border-radius: 8px;
    padding: 8px 12px;
}
#searchBox:focus {
    border: 1px solid #3a6df0;
}

#snippetList {
    background-color: transparent;
    border: none;
    outline: none;
}
#snippetList::item {
    background-color: #ffffff;
    border: 1px solid #e3e6ee;
    border-radius: 10px;
    padding: 0px;
}
#snippetList::item:selected {
    border: 2px solid #1f2329;
}

#copyTip {
    background-color: transparent;
    border: none;
    color: #00b42a;
    font-size: 13px;
    font-weight: 600;
}

#cardWidget {
    background-color: transparent;
    border: none;
}

#cardTitle {
    background-color: transparent;
    border: none;
    color: #1f2329;
    font-size: 15px;
    font-weight: 600;
}

#cardLabel {
    background-color: transparent;
    border: none;
    color: #646a73;
    font-size: 13px;
}

#cardActionBtn, #cardActionDangerBtn {
    background-color: transparent;
    border: none;
    border-radius: 6px;
    padding: 2px 8px;
    color: #1f2329;
    font-size: 12px;
}
#cardActionBtn:hover, #cardActionDangerBtn:hover {
    background-color: #f0f1f3;
    color: #1f2329;
}
#cardActionBtn:pressed, #cardActionDangerBtn:pressed {
    background-color: #e6e7ea;
    color: #1f2329;
}

#titleBarBtn {
    background-color: transparent;
    border: none;
    border-radius: 6px;
    padding: 4px 2px;
    color: #1f2329;
    font-size: 18px;
}
#titleBarBtn:hover {
    background-color: #f0f1f3;
}
#titleBarBtn:pressed {
    background-color: #e6e7ea;
}

QMenu {
    background-color: #eef0f7;
    border: 1px solid #d9dce8;
    border-radius: 5px;
    padding: 6px;
}
QMenu::item {
    background-color: transparent;
    padding: 8px 18px;
    border-radius: 6px;
    color: #1f2329;
    font-size: 14px;
}
QMenu::item:selected {
    background-color: #dfe2ee;
}

QPushButton {
    background-color: #ffffff;
    border: 1px solid #e3e6ee;
    border-radius: 8px;
    padding: 8px 14px;
}
QPushButton:hover {
    background-color: #f5f6fa;
}
QPushButton:pressed {
    background-color: #e9ebf2;
}

#dialogFieldLabel {
    background-color: transparent;
    border: none;
    color: #646a73;
    font-size: 13px;
    font-weight: 600;
}

#dialogTitleInput {
    background-color: #ffffff;
    border: 1px solid #e3e6ee;
    border-radius: 8px;
    padding: 8px 12px;
}
#dialogTitleInput:focus {
    border: 1px solid #3a6df0;
}

#dialogContentInput {
    background-color: #ffffff;
    border: 1px solid #e3e6ee;
    border-radius: 8px;
    padding: 8px 12px;
}
#dialogContentInput:focus {
    border: 1px solid #3a6df0;
}

#confirmDialog {
    background-color: #ffffff;
}
#confirmTitle {
    background-color: transparent;
    border: none;
    color: #1f2329;
    font-size: 16px;
    font-weight: 600;
}
#confirmMessage {
    background-color: transparent;
    border: none;
    color: #646a73;
    font-size: 14px;
}
#confirmCancelBtn {
    background-color: #ffffff;
    border: 1px solid #e3e6ee;
    border-radius: 8px;
    padding: 8px 18px;
    color: #1f2329;
}
#confirmCancelBtn:hover {
    background-color: #f5f6fa;
}
#confirmCancelBtn:pressed {
    background-color: #e9ebf2;
}
#confirmDangerBtn {
    background-color: #f53f3f;
    border: 1px solid #f53f3f;
    border-radius: 8px;
    padding: 8px 18px;
    color: #ffffff;
    font-weight: 600;
}
#confirmDangerBtn:hover {
    background-color: #e63333;
}
#confirmDangerBtn:pressed {
    background-color: #cc2d2d;
}
"""


class ElidedLabel(QLabel):
"""多行文本超出后以省略号结尾。"""

MAX_LINES = 2

def __init__(self, text="", parent=None, pad_x=0, pad_y=0):
super().__init__(parent)
self._full_text = text
self._pad_x = pad_x
self._pad_y = pad_y
self.setWordWrap(True)

def setText(self, text):
self._full_text = text
super().setText(text)

def paintEvent(self, event):
painter = QPainter(self)

pad_x, pad_y = self._pad_x, self._pad_y
rect = self.rect().adjusted(pad_x, pad_y, -pad_x, -pad_y)

metrics = QFontMetrics(self.font())
line_height = metrics.lineSpacing()

lines = []
current = ""
for ch in self._full_text:
if ch == "\n":
lines.append(current)
current = ""
continue
test = current + ch
if metrics.horizontalAdvance(test) > rect.width() and current:
lines.append(current)
current = ch
else:
current = test
if current:
lines.append(current)

if len(lines) > self.MAX_LINES:
lines = lines[:self.MAX_LINES]
lines[-1] = metrics.elidedText(
lines[-1] + "…",
Qt.TextElideMode.ElideRight,
rect.width(),
)

y = rect.top() + metrics.ascent()
for line in lines:
painter.drawText(rect.left(), y, line)
y += line_height

painter.end()


class SnippetDialog(QDialog):
"""新增/编辑弹窗：标题单行，内容多行（固定高度可滚动）。"""

def __init__(self, parent=None, window_title="新增", title="", content=""):
super().__init__(parent)

self.setWindowTitle(window_title)
self.setMinimumWidth(420)
self.setStyleSheet(STYLE_SHEET)

layout = QVBoxLayout(self)
layout.setContentsMargins(20, 20, 20, 20)
layout.setSpacing(8)

title_tip = QLabel("标题")
title_tip.setObjectName("dialogFieldLabel")
layout.addWidget(title_tip)

self.title_input = QLineEdit(title)
self.title_input.setObjectName("dialogTitleInput")
self.title_input.setPlaceholderText("请输入标题...")
layout.addWidget(self.title_input)

layout.addSpacing(6)

content_tip = QLabel("内容")
content_tip.setObjectName("dialogFieldLabel")
layout.addWidget(content_tip)

self.content_input = QTextEdit()
self.content_input.setObjectName("dialogContentInput")
self.content_input.setPlaceholderText("请输入内容...")
self.content_input.setPlainText(content)
self.content_input.setFixedHeight(220)
layout.addWidget(self.content_input)

layout.addSpacing(10)

button_box = QDialogButtonBox(
QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel
)
button_box.button(QDialogButtonBox.StandardButton.Ok).setText("确定")
button_box.button(QDialogButtonBox.StandardButton.Cancel).setText("取消")
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
layout.addWidget(button_box)

self.title_input.setFocus()

def get_values(self):
return (
self.title_input.text().strip(),
self.content_input.toPlainText().strip(),
)


class ConfirmDialog(QDialog):
"""与应用风格一致的确认弹窗：纯文本，无图标。"""

def __init__(
self,
parent=None,
title="确认",
message="",
ok_text="确定",
cancel_text="取消",
):
super().__init__(parent)

self.setObjectName("confirmDialog")
self.setWindowTitle(title)
self.setMinimumWidth(320)
self.setStyleSheet(STYLE_SHEET)

layout = QVBoxLayout(self)
layout.setContentsMargins(24, 22, 24, 20)
layout.setSpacing(10)

title_label = QLabel(title)
title_label.setObjectName("confirmTitle")
layout.addWidget(title_label)

message_label = QLabel(message)
message_label.setObjectName("confirmMessage")
message_label.setWordWrap(True)
layout.addWidget(message_label)

layout.addSpacing(8)

btn_row = QHBoxLayout()
btn_row.setSpacing(10)
btn_row.addStretch()

cancel_btn = QPushButton(cancel_text)
cancel_btn.setObjectName("confirmCancelBtn")
cancel_btn.clicked.connect(self.reject)

ok_btn = QPushButton(ok_text)
ok_btn.setObjectName("confirmDangerBtn")
ok_btn.clicked.connect(self.accept)

btn_row.addWidget(cancel_btn)
btn_row.addWidget(ok_btn)
layout.addLayout(btn_row)

cancel_btn.setFocus()


# 全局快捷键：使用 macOS Carbon RegisterEventHotKey 仅监听 Cmd+Y，
# 避免 pynput 全局事件 tap 在切换输入法时崩溃，且无需辅助功能权限。

class HotkeySignals(QObject):
trigger_show = pyqtSignal()


HOTKEY_SIGNALS = HotkeySignals()

try:
_CARBON = ctypes.CDLL(ctypes.util.find_library("Carbon"))
except Exception:
_CARBON = None


class _EventHotKeyID(ctypes.Structure):
_fields_ = [
("signature", ctypes.c_uint32),
("id", ctypes.c_uint32),
]


class _EventTypeSpec(ctypes.Structure):
_fields_ = [
("eventClass", ctypes.c_uint32),
("eventKind", ctypes.c_uint32),
]


_kEventClassKeyboard = 0x6B657962
_kEventHotKeyPressed = 5
_cmdKey = 0x0100
_kVK_ANSI_Y = 0x10
_HOTKEY_SIGNATURE = 0x736E7079
_HOTKEY_ID = 1

_HOTKEY_HANDLER_PROTO = ctypes.CFUNCTYPE(
ctypes.c_int32,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
)

# 模块级全局引用，防止被 GC 回收导致回调悬挂/崩溃
_HOTKEY_REF = None
_HOTKEY_HANDLER_REF = None
_HOTKEY_CALLBACK = None
_HOTKEY_INSTALLED = False


def _configure_carbon_signatures():
"""显式设置 Carbon 函数签名，避免 64 位指针被截断。"""
_CARBON.GetApplicationEventTarget.restype = ctypes.c_void_p
_CARBON.GetApplicationEventTarget.argtypes = []

_CARBON.InstallEventHandler.restype = ctypes.c_int32
_CARBON.InstallEventHandler.argtypes = [
ctypes.c_void_p,
_HOTKEY_HANDLER_PROTO,
ctypes.c_uint32,
ctypes.POINTER(_EventTypeSpec),
ctypes.c_void_p,
ctypes.POINTER(ctypes.c_void_p),
]

_CARBON.RegisterEventHotKey.restype = ctypes.c_int32
_CARBON.RegisterEventHotKey.argtypes = [
ctypes.c_uint32,
ctypes.c_uint32,
_EventHotKeyID,
ctypes.c_void_p,
ctypes.c_uint32,
ctypes.POINTER(ctypes.c_void_p),
]

_CARBON.UnregisterEventHotKey.restype = ctypes.c_int32
_CARBON.UnregisterEventHotKey.argtypes = [ctypes.c_void_p]

_CARBON.RemoveEventHandler.restype = ctypes.c_int32
_CARBON.RemoveEventHandler.argtypes = [ctypes.c_void_p]


def _on_hotkey(_next_handler, _event, _user_data):
try:
HOTKEY_SIGNALS.trigger_show.emit()
except Exception:
pass
return 0


def start_hotkey():
"""注册全局热键（Cmd+Y），幂等。成功返回 True。"""
global _HOTKEY_REF, _HOTKEY_HANDLER_REF, _HOTKEY_CALLBACK
global _HOTKEY_INSTALLED

if _HOTKEY_INSTALLED:
return True
if _CARBON is None:
return False

try:
_configure_carbon_signatures()

target = _CARBON.GetApplicationEventTarget()
if not target:
return False

_HOTKEY_CALLBACK = _HOTKEY_HANDLER_PROTO(_on_hotkey)
event_spec = _EventTypeSpec(_kEventClassKeyboard, _kEventHotKeyPressed)
handler_ref = ctypes.c_void_p()
status = _CARBON.InstallEventHandler(
target,
_HOTKEY_CALLBACK,
1,
ctypes.byref(event_spec),
None,
ctypes.byref(handler_ref),
)
if status != 0:
_HOTKEY_CALLBACK = None
return False
_HOTKEY_HANDLER_REF = handler_ref

hotkey_id = _EventHotKeyID(_HOTKEY_SIGNATURE, _HOTKEY_ID)
hotkey_ref = ctypes.c_void_p()
status = _CARBON.RegisterEventHotKey(
_kVK_ANSI_Y,
_cmdKey,
hotkey_id,
target,
0,
ctypes.byref(hotkey_ref),
)
if status != 0:
try:
_CARBON.RemoveEventHandler(_HOTKEY_HANDLER_REF)
except Exception:
pass
_HOTKEY_HANDLER_REF = None
_HOTKEY_CALLBACK = None
return False
_HOTKEY_REF = hotkey_ref

_HOTKEY_INSTALLED = True
return True
except Exception:
return False


def stop_hotkey():
"""注销全局热键并移除事件处理器。"""
global _HOTKEY_REF, _HOTKEY_HANDLER_REF, _HOTKEY_CALLBACK
global _HOTKEY_INSTALLED

if _CARBON is None:
return

try:
if _HOTKEY_REF is not None:
_CARBON.UnregisterEventHotKey(_HOTKEY_REF)
except Exception:
pass

try:
if _HOTKEY_HANDLER_REF is not None:
_CARBON.RemoveEventHandler(_HOTKEY_HANDLER_REF)
except Exception:
pass

_HOTKEY_REF = None
_HOTKEY_HANDLER_REF = None
_HOTKEY_CALLBACK = None
_HOTKEY_INSTALLED = False


class SnippetWindow(QWidget):

def __init__(self):
super().__init__()

self.data = load_data()
self._drag_pos = None

self.setWindowTitle("Snippet Panel")
self.setWindowFlags(
Qt.WindowType.Tool
| Qt.WindowType.FramelessWindowHint
| Qt.WindowType.WindowStaysOnTopHint
)
self.resize(420, 560)
self.init_ui()

HOTKEY_SIGNALS.trigger_show.connect(self.force_show)

def init_ui(self):
layout = QVBoxLayout()
layout.setContentsMargins(16, 16, 16, 16)
layout.setSpacing(12)

self.title_bar = QWidget()
self.title_bar.setObjectName("titleBar")

top_bar = QHBoxLayout(self.title_bar)
top_bar.setContentsMargins(0, 0, 0, 0)

title_label = QLabel("短语板")
title_label.setObjectName("titleLabel")

self.copy_tip = QLabel("")
self.copy_tip.setObjectName("copyTip")
self.copy_tip.setMaximumWidth(180)
self.copy_tip.hide()

self._copy_tip_timer = QTimer(self)
self._copy_tip_timer.setSingleShot(True)
self._copy_tip_timer.timeout.connect(self.copy_tip.hide)

self.add_btn = QPushButton("+")
self.add_btn.setObjectName("titleBarBtn")
self.add_btn.setCursor(Qt.CursorShape.PointingHandCursor)
self.add_btn.clicked.connect(self.add_item)

self.menu_btn = QPushButton("···")
self.menu_btn.setObjectName("titleBarBtn")
self.menu_btn.setCursor(Qt.CursorShape.PointingHandCursor)
self.menu_btn.clicked.connect(self._show_menu)

top_bar.addWidget(title_label)
top_bar.addStretch()
top_bar.addWidget(self.copy_tip)
top_bar.addStretch()
top_bar.addWidget(self.add_btn)
top_bar.addWidget(self.menu_btn)

layout.addWidget(self.title_bar)

self.search = QLineEdit()
self.search.setObjectName("searchBox")
self.search.setPlaceholderText("搜索...")
self.search.textChanged.connect(self.refresh_list)
layout.addWidget(self.search)

self.list_widget = QListWidget()
self.list_widget.setObjectName("snippetList")
self.list_widget.setSpacing(8)
self.list_widget.itemDoubleClicked.connect(self._on_item_double_clicked)
layout.addWidget(self.list_widget)

self.setLayout(layout)
self.setStyleSheet(STYLE_SHEET)

self.refresh_list()

def refresh_list(self):
keyword = self.search.text().lower()
self.list_widget.clear()

for item in self.data:
if (
keyword in item["title"].lower()
or keyword in item["content"].lower()
):
self._add_card(item)

def _add_card(self, item):
title = item["title"]
content = item["content"]

list_item = QListWidgetItem(self.list_widget)
list_item.setSizeHint(QSize(0, 124))

card = QWidget()
card.setObjectName("cardWidget")

card_layout = QVBoxLayout(card)
card_layout.setContentsMargins(16, 12, 16, 8)
card_layout.setSpacing(6)

title_label = QLabel(title)
title_label.setObjectName("cardTitle")

content_label = ElidedLabel(content)
content_label.setObjectName("cardLabel")

card_layout.addWidget(title_label)
card_layout.addWidget(content_label)

action_row = QHBoxLayout()
action_row.setContentsMargins(0, 0, 0, 0)
action_row.setSpacing(4)
action_row.addStretch()

copy_btn = QPushButton("复制")
copy_btn.setObjectName("cardActionBtn")
copy_btn.setCursor(Qt.CursorShape.PointingHandCursor)
copy_btn.clicked.connect(lambda _=False, it=item: self._copy_item(it))

del_btn = QPushButton("删除")
del_btn.setObjectName("cardActionDangerBtn")
del_btn.setCursor(Qt.CursorShape.PointingHandCursor)
del_btn.clicked.connect(lambda _=False, it=item: self._delete_item(it))

action_row.addWidget(copy_btn)
action_row.addWidget(del_btn)
card_layout.addLayout(action_row)

self.list_widget.addItem(list_item)
self.list_widget.setItemWidget(list_item, card)

def get_selected_index(self):
row = self.list_widget.currentRow()
if row < 0:
return None

keyword = self.search.text().lower()
filtered = [
item for item in self.data
if keyword in item["title"].lower()
or keyword in item["content"].lower()
]
return self.data.index(filtered[row])

def add_item(self):
dialog = SnippetDialog(self, window_title="新增")
if dialog.exec() != QDialog.DialogCode.Accepted:
return

title, content = dialog.get_values()
if not title:
return

self.data.append({"title": title, "content": content})
save_data(self.data)
self.refresh_list()

def edit_item(self):
idx = self.get_selected_index()
if idx is None:
return

item = self.data[idx]
dialog = SnippetDialog(
self,
window_title="编辑",
title=item["title"],
content=item["content"],
)
if dialog.exec() != QDialog.DialogCode.Accepted:
return

title, content = dialog.get_values()
if not title:
return

self.data[idx] = {"title": title, "content": content}
save_data(self.data)
self.refresh_list()

def _delete_item(self, item):
try:
idx = self.data.index(item)
except ValueError:
return
self._delete_by_index(idx)

def _delete_by_index(self, idx):
dialog = ConfirmDialog(
self,
title="删除",
message="确定要删除这条短语吗？",
ok_text="删除",
cancel_text="取消",
)
if dialog.exec() != QDialog.DialogCode.Accepted:
return

del self.data[idx]
save_data(self.data)
self.refresh_list()

def _on_item_double_clicked(self, list_item):
self.list_widget.setCurrentItem(list_item)
self.edit_item()

def _copy_item(self, item):
try:
idx = self.data.index(item)
except ValueError:
return
self._copy_by_index(idx)

def _copy_by_index(self, idx):
pyperclip.copy(self.data[idx]["content"])
self._show_copy_tip(self.data[idx]["title"])

def _show_copy_tip(self, title):
text = f"复制成功：{title}"
metrics = QFontMetrics(self.copy_tip.font())
elided = metrics.elidedText(
text,
Qt.TextElideMode.ElideRight,
self.copy_tip.maximumWidth(),
)
self.copy_tip.setText(elided)
self.copy_tip.show()
self._copy_tip_timer.start(1000)

def _show_menu(self):
menu = QMenu(self)
menu.setObjectName("titleMenu")

quit_action = QAction("结束进程", self)
quit_action.triggered.connect(self.force_quit)
menu.addAction(quit_action)

pos = self.menu_btn.mapToGlobal(self.menu_btn.rect().bottomRight())
menu.exec(pos - QPoint(menu.sizeHint().width(), 0))

def force_quit(self):
dialog = ConfirmDialog(
self,
title="强制结束",
message="确定要强制结束进程吗？应用将完全退出。",
ok_text="强制结束",
cancel_text="取消",
)
if dialog.exec() != QDialog.DialogCode.Accepted:
return

stop_hotkey()
os._exit(0)

def _close_child_dialogs(self):
"""关闭所有由主窗口打开的弹窗。"""
for dlg in self.findChildren(QDialog):
dlg.reject()
dlg.close()

def force_show(self):
self._close_child_dialogs()
self.show()
self.raise_()
self.activateWindow()
self.search.setFocus()

def mousePressEvent(self, event):
if event.button() == Qt.MouseButton.LeftButton:
pos = event.position().toPoint()
if pos.y() < self.title_bar.geometry().top():
self._drag_pos = (
event.globalPosition().toPoint()
- self.frameGeometry().topLeft()
)
event.accept()
return
super().mousePressEvent(event)

def mouseMoveEvent(self, event):
if (
self._drag_pos is not None
and event.buttons() & Qt.MouseButton.LeftButton
):
self.move(event.globalPosition().toPoint() - self._drag_pos)
event.accept()
return
super().mouseMoveEvent(event)

def mouseReleaseEvent(self, event):
self._drag_pos = None
super().mouseReleaseEvent(event)

def changeEvent(self, event):
if event.type() == QEvent.Type.ActivationChange:
if not self.isActiveWindow():
self.hide()
super().changeEvent(event)


if __name__ == "__main__":
app = QApplication(sys.argv)

window = SnippetWindow()
window.hide()

if not start_hotkey():
ConfirmDialog(
window,
title="快捷键注册失败",
message=(
"全局快捷键 Cmd+Y 注册失败，可能已被其他应用占用。\n\n"
"请关闭占用该组合键的应用后重启本程序。"
),
ok_text="我知道了",
cancel_text="关闭",
).exec()

sys.exit(app.exec())

Spring Security + Redis 的无状态分布式认证架构设计

Fri, 05 Jun 2026 22:59:33 +0800

传统Session和JWT的弊端

Session

在传统Web开发中，服务器通过Tomcat的 HttpSession（基于Cookie中的 JSESSIONID）维持状态。但在现代微服务与前后端分离架构下，这种方案存在天然弊端：

1.集群横向扩展困难：Session常驻单机内存，多台服务器间同步成本极高。

2.安全缺陷：基于Cookie的认证天然难以防范CSRF（跨站请求伪造）攻击。

3.为了解决有状态（Stateful）的痛点，业界普遍转向无状态（Stateless）架构。

JWT

JWT仅适用于单向、短期、无状态的边缘授权（如文件下载凭证、邮件激活码）；而对于需要强管控、高并发、支持滑动续期和踢人下线的企业级核心用户系统，Redis Token 才是生产环境的终极解法。

实现思路

1.请求进入网关或Tomcat后，自定义过滤器 RedisTokenFilter 拦截请求，解析 HTTP Header 中的 Authorization 字段。

2.过滤器拿着Token去Redis集群检索。若命中，则说明该用户处于合法登录状态。随后将其包装为框架可识别的令牌，注入 SecurityContextHolder（底层基于 ThreadLocal，确保多线程并发下的线程隔离与安全）。

3.请求流向Spring Security的核心鉴权层（AuthorizationFilter）。鉴权层根据 SecurityConfig 中配置的黑白名单规则，比对当前线程上下文中是否存在令牌。核验通过则放行至 Controller，否则直接响应 403。

代码实现

SQL数据表

如果你还想做权限管理，我建议把数据库的用户表，增加一个字段用来区分权限。

-- phpMyAdmin SQL Dump
-- version 5.2.3
-- 主机： localhost
-- 服务器版本： 5.7.44-log
-- PHP 版本： 8.2.28

SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
START TRANSACTION;
SET time_zone = "+00:00";


/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;

--
-- 数据库： `auth_study`
--

-- --------------------------------------------------------

--
-- 表的结构 `s_users`
--

CREATE TABLE `s_users` (
  `uid` int(11) NOT NULL,
  `role` varchar(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

--
-- 转存表中的数据 `s_users`
--

INSERT INTO `s_users` (`uid`, `role`) VALUES
(1, 'user'),
(2, 'admin');

--
-- 转储表的索引
--

--
-- 表的索引 `s_users`
--
ALTER TABLE `s_users`
  ADD PRIMARY KEY (`uid`);
COMMIT;

/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;

SecurityConfig

可以看到，login接口是所有人哪怕未登录的游客也可以访问，但是admin接口是必须要权限为admin的用户才可以访问，hello接口的话登录了都可以访问

package com.redisauth.config;

import com.redisauth.util.RedisUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    private final RedisUtils redisUtils;

    public SecurityConfig(RedisUtils redisUtils) {
        this.redisUtils = redisUtils;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                .csrf(AbstractHttpConfigurer::disable)
                .formLogin(AbstractHttpConfigurer::disable)
                .httpBasic(AbstractHttpConfigurer::disable)
                .addFilterBefore(new AuthorityFilter(redisUtils), UsernamePasswordAuthenticationFilter.class)
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                .authorizeHttpRequests(
                        auth -> auth
                                .requestMatchers("/login").permitAll() // 允许未登录时访问登录接口
                                .requestMatchers("/admin").hasRole("admin") // 允许用户权限为admin的用户登录
                                .anyRequest().authenticated() // 其它所有剩余接口默认都需要登录
                );
        return http.build();
    }
}

AuthorityFilter

当客户端携带该Token请求受保护的业务接口时，请求首先被AuthorityFilter安全过滤器拦截，过滤器从请求头提取出Token并拼接成对应的TokenKey去Redis中检索JSON字符串，若未命中则直接放行，由后续的Spring Security鉴权拦截器因上下文为空而统一响应403拒绝访问。如果成功获取到JSON字符串，过滤器会将其反序列化解析出用户ID和角色，随后为了防御僵尸Token偷跑，过滤器利用解析出的用户ID实时去Redis中读取最新的UidKey，并将当前请求携带的Token与Redis中记录的最新活跃Token进行字符串一致性比对。若比对完全一致，证明当前请求来自最后登录的合法设备，过滤器便为该角色组装框架认账的权限列表并注入当前请求的线程上下文中恢复合法身份，同时同步为当前的TokenKey和UidKey执行expire操作完成生命周期对齐的滑动续期；反之若比对不一致，说明该Token已被新设备顶替，过滤器则直接拒绝恢复其身份并顺手将该残余的TokenKey从Redis中连根拔除以释放内存，最后调用过滤链放行方法将请求安全传递给后续的路由鉴权关卡。

package com.redisauth.config;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.redisauth.util.RedisUtils;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class AuthorityFilter extends OncePerRequestFilter {

    private final RedisUtils redisUtils;
    private final ObjectMapper objectMapper = new ObjectMapper();

    public AuthorityFilter(RedisUtils redisUtils) {
        this.redisUtils = redisUtils;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        String token = request.getHeader(redisUtils.HEADER);

        if (StringUtils.hasText(token)) {
            String redisKey = redisUtils.tokenPreKey + token;
            String jsonStr = redisUtils.get(redisKey);

            if (StringUtils.hasText(jsonStr)) {
                try {
                    // 1. 解析 JSON 数据
                    JsonNode jsonNode = objectMapper.readTree(jsonStr);
                    String uid = jsonNode.get("uid").asText();
                    String role = jsonNode.get("role").asText();

                    // ===== 漏掉的单端核心校验开始 =====
                    String uidKey = redisUtils.uidPreKey + uid;
                    String currentActiveToken = redisUtils.get(uidKey);

                    if (token.equals(currentActiveToken)) {
                        // 只有携带的 Token 确实是当前 Redis 记录的最活跃 Token 时，才放行并续期
                        List<GrantedAuthority> authorities = new ArrayList<>();
                        authorities.add(new SimpleGrantedAuthority("ROLE_" + role));

                        UsernamePasswordAuthenticationToken authentication =
                                new UsernamePasswordAuthenticationToken(uid, null, authorities);
                        SecurityContextHolder.getContext().setAuthentication(authentication);

                        // 同步双向续期
                        redisUtils.expire(redisKey, 30, TimeUnit.MINUTES);
                        redisUtils.expire(uidKey, 30, TimeUnit.MINUTES);
                    } else {
                        // 旧设备，直接从 Redis 删除
                        redisUtils.delete(redisKey);
                    }
                    // ===== 单端核心校验结束 =====
                } catch (Exception e) {
                    this.logger.error("解析用户安全上下文失败", e);
                }
            }
        }
        filterChain.doFilter(request, response);
    }
}

TestController

当用户调用登录接口并传入用户ID时，系统首先通过Mapper映射器校验该用户在数据库中是否存在，若不存在则直接返回错误提示阻断流程。校验通过后，系统利用定义在工具类中的统一前缀配合用户ID拼接出唯一的UidKey，并立即去Redis中检索该键对应的值，若能获取到说明该账号此前已在其他设备登录。此时系统会严格遵循先清道后建新凭证的顺序，立刻调用删除命令将该旧Token作为键的TokenKey从Redis内存中彻底抹除，以此确保旧设备的身份凭证死透，从根本上解决高并发下的数据覆盖Bug。清除完旧通道后，系统利用UUID生成一个全新的Token串并组装出对应的新TokenKey，同时将最新的用户ID和角色信息格式化为JSON字符串，随后执行双向绑定写入，即把JSON字符串存入新TokenKey，把新Token串反向覆盖写入UidKey，并为这两个键设置完全一致的三十分钟逻辑过期时间，最后将新Token返回给前端。

package com.redisauth.controller;


import com.redisauth.entity.SUsers;
import com.redisauth.mapper.SUsersMapper;
import com.redisauth.util.RedisUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
public class TestController {

    @Autowired
    private SUsersMapper sUsersMapper;
    @Autowired
    private RedisUtils redisUtils;

    @PostMapping("/login")
    public String login(@RequestParam("uid") int uid) {
        SUsers sUsers = sUsersMapper.selectByPrimaryKey(uid);
        if (sUsers == null) {
            return "login failed";
        }

        String uidKey = redisUtils.uidPreKey + sUsers.getUid();

        // 1. 严格先行：先检查并干掉旧设备，确保当前 Uid 相关的旧通道被完全清理
        String oldToken = redisUtils.get(uidKey);
        if (StringUtils.hasText(oldToken)) {
            redisUtils.delete(redisUtils.tokenPreKey + oldToken);
        }

        // 2. 后行：旧设备死透了，再开始为新设备张罗新凭证
        String newToken = UUID.randomUUID().toString();
        String tokenKey = redisUtils.tokenPreKey + newToken;
        String jsonValue = String.format("{\"uid\":%d,\"role\":\"%s\"}", sUsers.getUid(), sUsers.getRole());

        // 3. 双向绑定写入 Redis
        redisUtils.set(tokenKey, jsonValue, 30, TimeUnit.MINUTES);
        redisUtils.set(uidKey, newToken, 30, TimeUnit.MINUTES);

        return newToken;
    }

    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }

    @GetMapping("admin")
    public String admin() {
        return "admin";
    }


}

RedisUtils

redis相关做了封装，方便一点

package com.redisauth.util;

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * Redis 基础操作通用工具类（基于 StringRedisTemplate）
 */
@Component
public class RedisUtils {

    private final StringRedisTemplate redisTemplate;
    public String HEADER = "Authorization";
    public String uidPreKey = "RedisAuth:uid:";
    public String tokenPreKey = "RedisAuth:token:";

    public RedisUtils(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 写入缓存
     */
    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 写入缓存并设置过期时间
     */
    public void set(String key, String value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /**
     * 读取缓存
     */
    public String get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 读取 Hash 指定字段值
     */
    public String hGet(String key, String field) {
        Object value = redisTemplate.opsForHash().get(key, field);
        return value != null ? value.toString() : null;
    }

    /**
     * 删除 Key
     */
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 设置/更新 Key 过期时间
     */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 检查 Key 是否存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
}

主程序入口

目的是关闭spring security自带的登录，以及mapper扫描

package com.redisauth;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration;

@SpringBootApplication(exclude = {UserDetailsServiceAutoConfiguration.class})
@MapperScan("com.redisauth.mapper")
public class RedisAuthApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisAuthApplication.class, args);
    }

}

LSPosed和LSPatch插件开发教程

Wed, 03 Jun 2026 23:12:21 +0800

简介

其实他们都是基于xposed出现的框架，只是扩展了两个而已，所以他们的编程体系相同，但是LSPatch相比于LSPosed可以不需要root，但是其功能肯定不如LSPosed全面，同时呢，两个框架的运行模式也有不同

LSPosed教程

创建项目

打开Android studio

点New Project

点Empty Views Activity

编程语言选java

构建选build.gradle

插件模块配置

打开AndroidManifest.xml添加如下配置

        <!-- 是否为Xposed模块 -->
        <meta-data
            android:name="xposedmodule"
            android:value="true"/>
        <!-- 模块的简介（在框架中显示） -->
        <meta-data
            android:name="xposeddescription"
            android:value="我是Xposed模块简介" />
        <!-- 模块最低支持的Api版本 一般填54即可 -->
        <meta-data 
            android:name="xposedminversion"     
            android:value="54"/>

另外提一嘴没有用的

        android:icon="@drawable/icon" //换图标
        android:label="@string/app_name" //换名字
        android:roundIcon="@drawable/icon" //换图标

添加仓库配置

打开setting.gradle添加

maven { url=uri("https://api.xposed.info") }

导入jar包

打开app module的build.gradle 添加

compileOnly 'de.robv.android.xposed:api:82'

创建xposed_init

将左上角选择为project，右键main，选择新建一个Directory，然后选择assets

再在该目录下新建一个file，记住一定是file，没有后缀名文件名叫xposed_init

其内为如下内容，其中com.xxx.xxx是你的包名，如果你不知道，你可以打开MainActivity.java中第一行，package com.xxx.xxx，那个就是你的包名，MainHook是我们的xposed类名，稍等再创建这个类

com.xxx.xxx.MainHook

Xposed Hook代码

在和MainActivity相同的目录下新建MainHook.java，代码如图，第一行是你的包名，记住不要全部复制嗷

package com.yuer.study;//包名记得替换

import de.robv.android.xposed.IXposedHookLoadPackage;
import de.robv.android.xposed.XposedBridge;
import de.robv.android.xposed.callbacks.XC_LoadPackage;

public class MainHook implements IXposedHookLoadPackage {

    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable {
        XposedBridge.log("yuerlv " + "启动 " + lpparam.packageName + " 成功咯");
    }

}

运行

然后你打开LSPosed，勾选需要的App，再把该模块打开，看日志即可

MySQL+Redis+RabbitMQ解决并发问题

Mon, 01 Jun 2026 13:56:22 +0800

引言

由于业务不方便展示，此处特定构造了一个新的业务场景。

假设每个用户有一个uid字段和hot字段，游客可以为uid为1的用户点赞，点赞一次数值加1，一个游客还好，那万一有很多很多呢

我写了一个demo，未进行任何并发处理的源码已经分享，方便大家参考

https://github.com/Anyuer9837/ConcurrencyStudy

其中数据库建议云的，家用的笔记本电脑或者台式电脑，一般来说性能都不错，很难压力测试，或者说效果不明显，所以我留下了可以使用的MySQL服务器进行在src/main/resources/application.properties 里面

同时希望大佬可以手下留情，我这为爱发电，希望大家别搞破坏，和平交流学习！共同进步！

问题分析

其实问题的原因很简单，当有大规模用户同时对MySQL的某一行数据的每一个字段进行写入的时候，会出现异常问题，

解决思路

针对这种高并发单点读写的瓶颈，整体的应对策略是利用分布式锁控制并发、缓存承载高频读写、消息队列异步削峰落库以及异常反向补偿的组合方案。

程序开始先获取十五秒的分布式锁。这样做是为了让并发请求针对该用户串行排队，防止高并发在缓存失效时同时击穿到数据库，也避免了多线程交错计算导致的数据覆盖。

拿到锁后优先读取缓存，有数据则直接使用，无数据则去数据库查询基数并回填。优先读缓存利用了内存的高性能，缓存缺失时去数据库查询并在锁的保护下回填，确保了冷启动时只有一个线程访问数据库，绝对安全。随后程序在内存中将热度加一，并立刻写回缓存，让前端能毫秒级感知最新状态。

缓存更新后，程序将数据打包发送给消息队列，发送成功即对前端返回成功。这种设计不等待慢速的数据库事务提交，利用队列作为蓄水池平滑落库，切断了高并发流量对底层数据库的直接冲击，实现了流量削峰。

如果发送队列失败，程序会立刻捕获异常并执行缓存的原子递减，把刚才多加的数值原路减回去。这种反向补偿机制是为了在分布式系统遭遇局部网络故障时，及时撤销内存变更，保证缓存和数据库的数据最终一致性。

最后无论流程顺利还是抛出异常，程序都会在清理块中判断锁是否仍由当前线程持有，确认无误后再执行释放。这样可以防止当前线程因为自身卡顿导致锁超时后，去错误地释放正在保护其他线程的锁，完成了安全的生命周期闭环。

核心代码

代码已经贴到上方仓库的1.0分支，这里展示的是核心代码

查询逻辑+业务逻辑+发送消息到队列

    @Override
    public boolean updateHot(UserHot userHot) {
        String cacheKey = "user:hot:" + userHot.getUid();
        String lockKey = "lock:user-hot:" + userHot.getUid();
        RLock lock = redissonClient.getLock(lockKey);

        try {
            // 1. 尝试获取分布式锁，限时 5 秒
            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                int newHot;
                // 2. 隔离并发下的 Redis 操作
                try {
                    String cachedHot = redisTemplate.opsForValue().get(cacheKey);
                    int currentHot;
                    if (cachedHot != null) {
                        currentHot = Integer.parseInt(cachedHot);
                    } else {
                        UserHot dbData = userHotMapper.selectByPrimaryKey(userHot.getUid());
                        if (dbData == null) return false;
                        currentHot = dbData.getHot();
                        redisTemplate.opsForValue().set(cacheKey, String.valueOf(currentHot));
                    }
                    // 内存计算并回写 Redis
                    newHot = currentHot + 1;
                    redisTemplate.opsForValue().set(cacheKey, String.valueOf(newHot));
                } catch (Exception e) {
                    System.err.println("【❌ Redis故障】操作Redis失败，原因: " + e.getMessage());
                    return false;
                }
                // 3. 隔离 MQ 消息发送
                try {
                    String message = userHot.getUid() + "," + newHot;
                    rabbitTemplate.convertAndSend(
                            RabbitConfig.HOT_EXCHANGE,
                            RabbitConfig.HOT_ROUTING_KEY,
                            message
                    );
                    return true;
                } catch (Exception e) {
                    System.err.println("【MQ故障】消息发送到RabbitMQ失败！原因: " + e.getMessage());

                    // 💡 开始执行回滚逻辑
                    System.out.println("【触发回滚】正在将 Redis 数据恢复原状...");
                    try {
                        // 使用 decrement 原子操作，把刚才加的 1 减回去
                        redisTemplate.opsForValue().decrement(cacheKey);
                        System.out.println("【回滚成功】Redis 数据已撤销，保证了数据一致性。");
                    } catch (Exception rollbackEx) {
                        // 🚨 极端边缘场景：刚才写 Redis 还好好的，回滚的时候 Redis 突然宕机或断网了！
                        System.err.println("【致命灾难】MQ发送失败，且 Redis 回滚也失败！出现严重数据不一致！");
                        System.err.println("急需人工介入！出问题的 UID: " + userHot.getUid() + "，报错: " + rollbackEx.getMessage());
                        // 真实生产环境中，这里通常会打印 Error 级别日志触发钉钉/邮件报警，
                        // 或者把这条失败记录写到一个本地磁盘日志文件里，等重启后人工修数据。
                    }
                    return false;
                }
            } else {
                System.out.println("【锁竞争激烈】获取分布式锁超时，其他线程正占用锁，本次更新放弃。");
                return false;
            }
        } catch (InterruptedException e) {
            System.out.println("【线程中断】等待锁的过程中线程被中断: " + e.getMessage());
            Thread.currentThread().interrupt();
            return false;
        } finally {
            // 严格释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

消费者

    @RabbitListener(queues = RabbitConfig.HOT_QUEUE)
    public void receiveUserHotMessage(String message) {
        try {
            // 1. 解析消息（把 "1,11" 拆成 uid=1, hot=11）
            String[] parts = message.split(",");
            Integer uid = Integer.parseInt(parts[0]);
            Integer newHot = Integer.parseInt(parts[1]);
            UserHot updateData = new UserHot();
            updateData.setUid(uid);
            updateData.setHot(newHot);
            userHotMapper.updateByPrimaryKeySelective(updateData);

            // System.out.println("【MQ成功落盘】用户 " + uid + " 的热度已同步为 " + newHot);
        } catch (Exception e) {
            System.err.println("【MQ消费失败】" + e.getMessage());
            // 注意：这里如果抛出异常，RabbitMQ 会自动把这条消息重新放回队列头部，实现自动重试！
            throw e;
        }
    }

安卓设备翻墙后将代理分享给局域网其他设备

Sun, 31 May 2026 12:56:16 +0800

找到你的翻墙软件，打开设置，允许来自局域网的连接打开。

然后，其它设备找到wifi，代理改为手动，输入翻墙的局域网设备ip和端口

Cloudflare Tunnel 局域网服务变到公网

Sat, 30 May 2026 22:55:15 +0800

这一招真的是太屌了，之前还要用各种内网穿透的软件，什么花生壳啊之类的，等等，就算公开了，域名也不能自行绑定，但是Cloudflare Tunnel 打通了这个通道，而且过程非常方便，现在教大家跑通这个流程。

Windows

打开cloudflare官网

https://dash.cloudflare.com/

创建隧道

输入一个隧道名称

然后，下载对应的配置工具

下载完成后，双击运行。记得以管理员权限打开

然后输入命令，命令必须复制cloudflare发给你的

然后你就会发现成功了，点击创建就可以了

然后就是创建路由了，点击刚才的隧道，进去后点击添加路由

然后选择本地已经开启的服务

然后选择你在cloudflare绑定的域名，再加一个二级域名，再输入本地的服务，最后点击添加路由，就完事了

然后就可以通过域名进行访问了。

但是现在目前来看，一个设备只能一个cloudflare服务，如果你要把当前的设备进行更换隧道，那么就必须卸载掉原有隧道才行

cloudflared service uninstall

Android

我的发，太伟大了，这种服务也可以让termux部署，先输入如下命令

apt install cloudflared

然后其他流程一模一样。。。。。。。

ALTER USER 'root'@'localhost' IDENTIFIED BY '你的新密码';
FLUSH PRIVILEGES;

MyBatisCodeHelper免费版

Fri, 29 May 2026 16:01:57 +0800

MyBatisCodeHelper好用是好用，就是不免费这太难受了，整理了一下大佬破解的免费的版本

通过网盘分享的文件：MyBatisCodeHelper-Pro-3.4.4_2321-2023.2-2025.1obfuscated.zip
链接: https://pan.baidu.com/s/1Jccn2qWRoryGgBSHxGzLeQ?pwd=yuer 提取码: yuer 
--来自百度网盘超级会员v4的分享

去掉Ai生成的ppt里面的水印

Thu, 21 May 2026 15:38:48 +0800

Ai网址是

https://gamma.app/

原理介绍

ppt、apk等文件其实都是能通过特定方式进行解压的，原因很简单，那么多图片文字等等资源都在一个文件格式里面，肯定是要把文件塞进去才行的，而我门的ppt或者pptx，你可以直接修改为zip，然后进行解压就好了。大原理是这样，而Ai的生成的ppt大部分水印其实是一张图片进行叠加的，解压了之后，进去替换掉对应的水印文件就好了

具体教程

先将文件后缀名修改为zip，再进行解压，然后打开如下目录

\ppt\media

查看每张图片，找到水印的图片，比如gamma的水印图片就是image2.png

然后随便利用一个空白图片进行替换，就比如我下面这个

额，它真的有，但是由于是空白的，所以你看不到，如果你看得到的话，到时候替换过去的图片你也就能看到了，所以肯定是不好的，这里提供下载链接

https://pan.anyuer.club/zb_users/upload/2026/05/202605211779349572737518.png