一个欲儿的博客

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://www.anyuer.club/zb_users/upload/2026/05/202605211779349572737518.png

Ubuntu linux 系统通过swap增加虚拟内存

Wed, 20 May 2026 17:42:04 +0800

添加教程

示例是添加2G的swap文件

1.创建 Swap 文件
sudo fallocate -l 2G /swapfile2

2.设置安全权限（非常重要）
sudo chmod 600 /swapfile2

3.初始化 Swap
sudo mkswap /swapfile2

4.启用 Swap
sudo swapon /swapfile2

5.设置开机自启
sudo nano /etc/fstab

6.末尾行加入
/swapfile2 none swap sw 0 0

检验成果

此时输入

swapon --show

可以看到新添加的

神画——魔术师心灵魔术教程

Wed, 20 May 2026 14:37:53 +0800

简介：

一个神奇的心灵魔术，你可以提前猜到用户接下来要说的数字，可以直接用观众手机打开下方网址进行表演

www.anyuer.club/draw_board/

基础功能：

颜色 - 点击颜色块选择画笔颜色（红、蓝、绿、黑）

笔刷 - 拖动滑块调节笔刷大小（1-60px）

撤销 - 撤销上一步操作（最多保存30步历史）

清除 - 清空画布内容

保存 PNG - 将画作导出为PNG图片

魔术表演教程：

1. 准备阶段 - 让观众从1-4中随机选择一个数字

2. 预言环节 - 告诉观众你已经提前知道答案并写在画板上（但不给观众看）

3. 假装作画 - 在观众看不到的地方，点击笔刷大小数值区域（例如"4px"）进入隐藏模式

4. 四宫格模式 - 系统进入四宫格模式，将手机背面朝向观众

5. 揭晓答案 - 询问观众他们选择的数字，然后点击对应四宫格位置，翻转手机给观众看答案！

神相——魔术师的 AR 卡牌应用

Thu, 14 May 2026 00:44:38 +0800

下载地址

链接: https://pan.baidu.com/s/1xaaknh7a-EPOW75nTM6IlA?pwd=yuer 提取码: yuer

详细使用教程

两个链接地址任选其一，内容完全一致，哪个能打开用哪个

https://github.com/Anyuer9837/magicCamera
https://notebook.anyuer.club/public.php?id=MagicCamera

简易使用教程

首先点击快门键，屏幕会闪烁一下，这个时候屏幕进入花色选择状态，不会有任何提示，对应的区域就是对应的花色

选完花色后，再次进入点数选择模式，对应区域就是对应的点数

然后就可以进行卡牌替换了。