# Redis深度实战：从源码原理到生产级应用
## 目录
1. [Redis核心架构与数据结构](#1-redis核心架构与数据结构)
2. [设计模式在Redis中的应用](#2-设计模式在redis中的应用)
3. [Java客户端反射机制深度应用](#3-java客户端反射机制深度应用)
4. [自定义注解实现缓存策略](#4-自定义注解实现缓存策略)
5. [Redis性能优化与JVM调优](#5-redis性能优化与jvm调优)
6. [生产级Redis工具类完整实现](#6-生产级redis工具类完整实现)
7. [分布式锁实战](#7-分布式锁实战)
8. [缓存穿透/击穿/雪崩解决方案](#8-缓存穿透击穿雪崩解决方案)
---
## 1. Redis核心架构与数据结构
### 1.1 Redis对象系统（基于单例模式和工厂模式）
Redis使用单例模式来管理数据库实例，每个Redis服务器进程维护一个全局唯一的`redisServer`对象。
```c
/* redis.h - Redis服务器对象定义 */
struct redisServer {
// 单例模式：全局唯一的服务器实例
int port; /* TCP listening port */
int fd; /* TCP file descriptor */
redisDb *db; /* 多数据库支持 */
int dbnum; /* Total number of initialized DBs */
// 工厂模式：创建不同类型的对象
dict *commands; /* Command table */
// 时间事件处理器
aeEventLoop *el; /* Event loop */
};
```
### 1.2 五大基础数据结构实现
```java
/**
* Redis五大基础数据结构Java封装
* 基于工厂模式创建不同类型的Redis对象
*/
public class RedisDataStructure {
/**
* 数据结构类型枚举
*/
public enum DataType {
STRING, LIST, HASH, SET, ZSET
}
/**
* 工厂方法：根据类型创建对应的Redis数据结构
*/
public static RedisObject create(DataType type) {
switch (type) {
case STRING:
return new RedisString();
case LIST:
return new RedisList();
case HASH:
return new RedisHash();
case SET:
return new RedisSet();
case ZSET:
return new RedisSortedSet();
default:
throw new IllegalArgumentException("不支持的Redis数据类型: " + type);
}
}
/**
* Redis对象基类（模板方法模式）
*/
public static abstract class RedisObject {
protected String key;
// 模板方法：定义操作流程
public final boolean save(String key) {
if (!validateKey(key)) {
return false;
}
this.key = key;
return doSave();
}
protected abstract boolean doSave();
protected abstract boolean validateKey(String key);
}
/**
* String类型实现（SDS - Simple Dynamic String）
*/
public static class RedisString extends RedisObject {
private byte[] value;
@Override
protected boolean doSave() {
// 模拟Redis SDS实现
// SDS结构：len + free + buf
byte[] sds = new byte[value.length + 1]; // len字段
System.arraycopy(value, 0, sds, 1, value.length);
sds[0] = (byte) value.length;
return true;
}
@Override
protected boolean validateKey(String key) {
return key != null && !key.isEmpty();
}
public void set(byte[] value) {
this.value = value;
}
public byte[] get() {
return value;
}
}
/**
* List类型实现（双向链表或压缩列表）
*/
public static class RedisList extends RedisObject {
private List list = new LinkedList<>();
@Override
protected boolean doSave() {
// 当元素数量小于512且每个元素小于64字节时使用压缩列表
// 否则使用双向链表
return true;
}
@Override
protected boolean validateKey(String key) {
return key != null;
}
public void lpush(byte[] value) {
list.add(0, value);
}
public byte[] rpop() {
return list.isEmpty() ? null : list.remove(list.size() - 1);
}
public long llen() {
return list.size();
}
}
/**
* Hash类型实现（字典/哈希表）
*/
public static class RedisHash extends RedisObject {
private Map map = new HashMap<>();
@Override
protected boolean doSave() {
// Redis哈希表使用渐进式rehash
return true;
}
@Override
protected boolean validateKey(String key) {
return key != null;
}
public void hset(String field, byte[] value) {
map.put(field, value);
}
public byte[] hget(String field) {
return map.get(field);
}
}
/**
* Set类型实现（整数集合或哈希表）
*/
public static class RedisSet extends RedisObject {
private Set set = new HashSet<>();
@Override
protected boolean doSave() {
return true;
}
@Override
protected boolean validateKey(String key) {
return key != null;
}
public void sadd(byte[] member) {
set.add(member);
}
public boolean sismember(byte[] member) {
return set.contains(member);
}
}
/**
* Sorted Set类型实现（跳表+字典）
*/
public static class RedisSortedSet extends RedisObject {
// 字典：member -> score
private Map dict = new HashMap<>();
// 跳表：按score排序
private TreeMap> zset = new TreeMap<>();
@Override
protected boolean doSave() {
return true;
}
@Override
protected boolean validateKey(String key) {
return key != null;
}
public void zadd(byte[] member, double score) {
dict.put(member, score);
zset.computeIfAbsent(score, k -> new HashSet<>()).add(member);
}
public Double zscore(byte[] member) {
return dict.get(member);
}
}
}
```
---
## 2. 设计模式在Redis中的应用
### 2.1 单例模式 - Redis连接池管理
```java
/**
* Redis连接池 - 单例模式
* 确保全局只有一个连接池实例，避免资源浪费
*/
public class RedisConnectionPool {
// 饿汉式单例
private static final RedisConnectionPool INSTANCE = new RedisConnectionPool();
// 连接池配置
private JedisPool jedisPool;
private final JedisPoolConfig poolConfig;
/**
* 私有构造函数
*/
private RedisConnectionPool() {
this.poolConfig = new JedisPoolConfig();
initializePoolConfig();
}
/**
* 获取单例实例
*/
public static RedisConnectionPool getInstance() {
return INSTANCE;
}
/**
* 初始化连接池配置
*/
private void initializePoolConfig() {
// 最大连接数
poolConfig.setMaxTotal(200);
// 最大空闲连接数
poolConfig.setMaxIdle(50);
// 最小空闲连接数
poolConfig.setMinIdle(10);
// 获取连接时的最大等待时间
poolConfig.setMaxWaitMillis(3000);
// 连接有效性检测
poolConfig.setTestOnBorrow(true);
poolConfig.setTestOnReturn(false);
poolConfig.setTestWhileIdle(true);
// 空闲连接检测周期
poolConfig.setTimeBetweenEvictionRunsMillis(60000);
// 空闲连接最小空闲时间
poolConfig.setMinEvictableIdleTimeMillis(300000);
// 连接超时时间
poolConfig.setSoTimeout(3000);
}
/**
* 初始化连接池
*/
public synchronized void init(String host, int port, String password) {
if (jedisPool != null && !jedisPool.isClosed()) {
return;
}
jedisPool = new JedisPool(poolConfig, host, port, 2000, password);
System.out.println("Redis连接池初始化成功: " + host + ":" + port);
}
/**
* 获取Redis连接
*/
public Jedis getResource() {
if (jedisPool == null) {
throw new IllegalStateException("Redis连接池未初始化");
}
return jedisPool.getResource();
}
/**
* 关闭连接池
*/
public synchronized void close() {
if (jedisPool != null && !jedisPool.isClosed()) {
jedisPool.close();
System.out.println("Redis连接池已关闭");
}
}
/**
* 获取连接池状态
*/
public Map getPoolStats() {
Map stats = new HashMap<>();
stats.put("numActive", jedisPool.getNumActive());
stats.put("numIdle", jedisPool.getNumIdle());
stats.put("numWaiters", jedisPool.getNumWaiters());
return stats;
}
}
```
### 2.2 工厂模式 - 序列化器工厂
```java
/**
* 序列化器工厂 - 工厂模式
* 根据不同类型创建对应的序列化器
*/
public class SerializerFactory {
/**
* 序列化器类型枚举
*/
public enum SerializerType {
JDK_SERIALIZABLE, // Java原生序列化
JSON, // JSON序列化
PROTOSTUFF, // Protostuff序列化
KRYO, // Kryo序列化
HESSIAN // Hessian序列化
}
/**
* 缓存已创建的序列化器实例
*/
private static final Map SERIALIZER_CACHE =
new ConcurrentHashMap<>();
/**
* 工厂方法：创建序列化器
*/
public static RedisSerializer create(SerializerType type) {
return SERIALIZER_CACHE.computeIfAbsent(type, t -> {
switch (t) {
case JDK_SERIALIZABLE:
return new JdkSerializer();
case JSON:
return new JsonSerializer();
case PROTOSTUFF:
return new ProtostuffSerializer();
case KRYO:
return new KryoSerializer();
case HESSIAN:
return new HessianSerializer();
default:
throw new IllegalArgumentException("不支持的序列化类型: " + type);
}
});
}
/**
* 序列化器接口
*/
public interface RedisSerializer {
byte[] serialize(T obj) throws SerializationException;
T deserialize(byte[] data) throws SerializationException;
}
/**
* JDK原生序列化实现
*/
public static class JdkSerializer implements RedisSerializer
