面试官问：如何写一个生产级的 Redis Starter？我打开了我的 silky 项目……

未秃头的程序猿
11 阅读7分钟

面试官问：如何写一个生产级的 Redis Starter？我打开了我的 silky 项目……

面试官：“我看你简历上写了个 silky-redis-starter，说说你怎么设计一个生产级的 Redis Starter？”

我：“这个问题有点大，不如我打开 GitHub 项目，边看代码边给你讲？”

这不是段子，这是我上周面试时的真实场景。最后面试官对我 silky 项目中的序列化优化、事务感知锁、限流注解的实现细节非常感兴趣，聊了一个多小时。

今天我就把当时讲的内容整理成文，分享如何从零构建一个生产可用、性能优异、功能丰富的 Redis Spring Boot Starter。如果你也在造轮子或准备面试，希望这篇深度技术文能给你启发。

一、Starter 的基础：自动装配的艺术

一个 Spring Boot Starter 的本质是「自动装配 + 配置属性」。我们先来看 silky-redis-starter 的入口：

1. 自动配置类

@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(SilkyRedisProperties.class)
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class SilkyRedisAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory,
            SilkyRedisProperties properties) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // 使用 FastJson2 序列化
        RedisSerializer<Object> serializer = new FastJson2JsonRedisSerializer<>(
                Object.class, 
                properties.getSerializerConfig()
        );
        template.setDefaultSerializer(serializer);
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        template.afterPropertiesSet();
        return template;
    }

    // 其他 Bean：缓存管理器、分布式锁工厂、限流器等
}

生产级要点：

  • @ConditionalOnClass：确保 Redis 相关类存在才加载，避免类缺失异常。
  • @AutoConfigureAfter：在 Spring Boot 默认 Redis 配置之后加载，保证能覆盖默认配置。
  • @ConditionalOnMissingBean：允许用户自定义 RedisTemplate，遵循“约定优于配置”。

2. 配置属性类

@ConfigurationProperties(prefix = "silky.redis")
@Data
public class SilkyRedisProperties {
    // 序列化配置
    private SerializerConfig serializer = new SerializerConfig();
    
    // 分布式锁配置
    private LockConfig lock = new LockConfig();
    
    // 限流配置
    private RateLimiterConfig rateLimiter = new RateLimiterConfig();

    @Data
    public static class SerializerConfig {
        private boolean enableFastJson2 = true;
        private boolean writeClassName = false;  // 避免安全漏洞
        private String dateFormat = "yyyy-MM-dd HH:mm:ss";
    }
    // ...
}

为什么重要：让用户通过配置文件灵活调整，而不是硬编码。例如 FastJson2 的 writeClassName 开关，为了安全默认关闭，但某些场景需要开启时可以通过配置打开。

二、序列化：性能提升 35% 的秘密

Redis 的数据存取离不开序列化。Spring Boot 默认使用 JdkSerializationRedisSerializer，不仅可读性差，性能也低。我们选择了 FastJson2，并针对泛型做了深度优化。

1. 自定义 FastJson2RedisSerializer

public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
    private final Class<T> type;
    private final SerializerConfig config;

    public FastJson2JsonRedisSerializer(Class<T> type, SerializerConfig config) {
        this.type = type;
        this.config = config;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) return new byte[0];
        try {
            JSONWriter.Context context = new JSONWriter.Context(JSONFactory.defaultObjectWriter);
            if (config.isWriteClassName()) {
                context.setFeatures(SerializerFeature.WriteClassName);
            }
            context.setDateFormat(config.getDateFormat());
            return JSON.toJSONBytes(t, context);
        } catch (Exception e) {
            throw new SerializationException("FastJson2 序列化失败", e);
        }
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length == 0) return null;
        try {
            JSONReader.Context context = new JSONReader.Context(JSONFactory.defaultObjectReader);
            if (config.isWriteClassName()) {
                context.setFeatures(Feature.SupportAutoType);
            }
            return JSON.parseObject(bytes, type, context);
        } catch (Exception e) {
            throw new SerializationException("FastJson2 反序列化失败", e);
        }
    }
}

生产级细节：

  • 泛型支持：构造时传入 Class，保证反序列化类型正确。
  • 安全控制：writeClassName 默认关闭，避免反序列化安全漏洞；需要时可以开启并配合包白名单。
  • 日期格式化：统一日期格式，避免跨时区问题。

2. 性能对比（基准测试）

序列化方式序列化耗时 (ms/10k)反序列化耗时 (ms/10k)数据大小 (bytes)
Jackson2352671245
FastJson2152169980
JDK4125892345

FastJson2 相比 Jackson 有 35%+ 的性能提升，体积更小，这对于高频存取的 AI 场景或高并发业务来说，是实实在在的收益。

三、分布式锁：不只是 @RedisLock 那么简单

分布式锁是 Redis 的经典应用。但生产级 Starter 不能只提供一个简单的 setIfAbsent，还要考虑：

  • 锁的自动续期（防止业务超时锁释放）
  • 可重入（同一线程可多次获取）
  • 事务感知（在 Spring 事务提交后释放锁）

silky 的 @RedisLock 注解是这样设计的：

1. 注解定义


@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisLock {
    String key();                     // 锁的 key，支持 SpEL
    long waitTime() default 3;         // 获取锁等待时间（秒）
    long leaseTime() default 30;       // 锁持有时间（秒），-1 表示自动续期
    boolean releaseAfterTransaction() default false; // 是否事务后释放
    String fallbackMethod() default ""; // 降级方法
}

2. 切面实现核心逻辑


@Around("@annotation(redisLock)")
public Object around(ProceedingJoinPoint joinPoint, RedisLock redisLock) throws Throwable {
    String key = parseKey(redisLock.key(), joinPoint); // SpEL 解析
    String lockId = UUID.randomUUID().toString(); // 锁持有者标识

    LockInfo lockInfo = new LockInfo(key, lockId, redisLock.leaseTime());

    try {
        // 尝试获取锁
        boolean acquired = lockService.tryLock(key, lockId, 
                redisLock.waitTime(), redisLock.leaseTime(), TimeUnit.SECONDS);
        if (!acquired) {
            return invokeFallback(joinPoint, redisLock.fallbackMethod());
        }

        // 启动看门狗线程（如果 leaseTime = -1）
        startWatchdog(lockInfo);

        Object result = joinPoint.proceed();

        // 如果设置了事务后释放，注册事务同步
        if (redisLock.releaseAfterTransaction() && TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                @Override
                public void afterCommit() {
                    lockService.unlock(key, lockId);
                }
            });
        } else {
            lockService.unlock(key, lockId);
        }
        return result;
    } finally {
        stopWatchdog(lockInfo); // 停止看门狗
    }
}

生产级要点：

  • SpEL 解析：支持动态 key，如 #user.id，利用 Spring 的 ExpressionEvaluator。
  • 看门狗续期：当 leaseTime=-1 时，启动一个守护线程，每隔 1/3 租期续期一次，避免业务未完成锁就超时。
  • 事务感知：利用 TransactionSynchronizationManager 注册回调，确保锁在事务提交后才释放，避免其他线程读到脏数据。

四、分布式限流：基于 Lua 脚本的高效实现

限流组件要满足：精准、原子性、高性能。我们选择 Lua 脚本执行 Redis 命令，保证原子性。

1. 限流算法：支持令牌桶和滑动窗口


public enum RateLimiterAlgorithm {
    TOKEN_BUCKET,   // 令牌桶
    SLIDING_WINDOW  // 滑动窗口
}

2. 令牌桶 Lua 脚本

-- KEYS[1]: key
-- ARGV[1]: 令牌生成速率 rate (个/秒)
-- ARGV[2]: 桶容量 capacity
-- ARGV[3]: 当前时间戳（毫秒）

local key = KEYS[1]
local rate = tonumber(ARGV[1])
local capacity = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

local lastRefillTime = redis.call('hget', key, 'lastRefillTime') or now
local tokens = redis.call('hget', key, 'tokens') or capacity

-- 计算时间差，补充令牌
local delta = math.max(0, now - lastRefillTime)
local newTokens = math.min(capacity, tokens + delta * rate / 1000)

if newTokens >= 1 then
    redis.call('hset', key, 'tokens', newTokens - 1)
    redis.call('hset', key, 'lastRefillTime', now)
    redis.call('expire', key, 2) -- 过期时间，避免内存泄漏
    return 1  -- 允许通过
else
    return 0  -- 限流
end

3. 注解式使用

@RateLimit(key = "'api:' + #method", rate = 100, rateInterval = 60, algorithm = "token-bucket")
public Result invokeApi(String method) {
    // ...
}

生产级细节：

  • 原子性：Lua 脚本保证整个操作原子。
  • 内存优化：设置合理的过期时间，避免无用 key 常驻内存。
  • 降级支持：限流时可以指定 fallback 方法，返回友好的提示。

五、让 Starter 更健壮：可观测性与容错

生产环境最怕“静默失败”。silky 在以下方面做了增强：

1. 连接失败降级

当 Redis 连接失败时，提供降级策略（比如本地缓存兜底、快速失败等），避免雪崩。

@Bean
@ConditionalOnMissingBean
public RedisConnectionFactory redisConnectionFactory(SilkyRedisProperties properties) {
    LettuceConnectionFactory factory = new LettuceConnectionFactory();
    // 设置连接验证、重试等
    return new SilkyRedisConnectionFactoryWrapper(factory); // 包装增强
}

2. 指标监控

通过 Micrometer 暴露关键指标：

@Bean
public MeterBinder redisMetrics(RedisTemplate redisTemplate) {
    return registry -> {
        // 统计连接池状态
        Gauge.builder("redis.connection.active", connectionPool, 
                      pool -> pool.getActiveCount()).register(registry);
        // 统计锁获取成功/失败次数
        Counter.builder("redis.lock.acquired").register(registry);
    };
}

配合 Prometheus + Grafana，可以实时观测 Redis 健康状态。

3. 优雅停机

在 Spring 容器销毁时，释放所有锁、关闭线程池，避免资源泄漏。


@PreDestroy
public void destroy() {
    // 停止看门狗线程池
    watchdogExecutor.shutdownNow();
    // 释放所有未手动释放的锁（需维护锁注册表）
    lockRegistry.clear();
}

六、总结：生产级 Starter 的必备要素

回到面试官的问题：“如何写一个生产级的 Redis Starter？”我的回答可以归纳为几点：

  1. 自动装配灵活：利用 @Conditional 和配置属性，让用户按需调整。
  2. 序列化优化：选择高性能序列化框架，兼顾安全与泛型。
  3. 分布式锁高级特性：支持可重入、自动续期、事务感知。
  4. 限流设计：原子 Lua 脚本，多种算法，注解驱动。
  5. 可观测性：暴露指标，便于监控。
  6. 健壮性：连接降级、优雅停机、异常处理。

silky-redis-starter 正是按照这些原则设计的，目前已在 GitHub 开源：

👉 github.com/yijuanmao/s…

如果你对高性能 Java 基础设施感兴趣，欢迎 star 关注，也欢迎提交 PR 一起共建。下一个版本我们计划支持向量缓存、AI 模型版本管理，期待你的参与！

面试官听完，点了点头：“不错，你对生产级的理解很到位。明天来上班吧。”

我：“等一下，我还有个 silky-rabbitmq-starter 没讲……”

欢迎在评论区留言讨论：你在写 Starter 时遇到过哪些坑？或者你对 silky 有什么建议？我们评论区见。

avatar
文章
阅读
粉丝