5.springboot-redis spring cache中篇

1.spring cache解析

1.1.RedisCache和RedisCacheManager

1.1.1.结构

1.1.2.解析

• RedisCache使用RedisCacheWriter接口，用于对redis的读写；
• RedisCacheWriter
  • RedisCacheWriter和Cache接口的差异：
    • 所有方法都需要指定name，执行redis命令时如需加锁，name为锁的key；
    • RedisCacheWriter可根据正则清除缓存；

public interface RedisCacheWriter {

	//**静态方法，创建不带锁的RedisCacheWriter实例
	static RedisCacheWriter nonLockingRedisCacheWriter(RedisConnectionFactory connectionFactory) {
		Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
		return new DefaultRedisCacheWriter(connectionFactory);
	}

	//**静态方法，创建带锁的RedisCacheWriter实例
	static RedisCacheWriter lockingRedisCacheWriter(RedisConnectionFactory connectionFactory) {
		Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
		return new DefaultRedisCacheWriter(connectionFactory, Duration.ofMillis(50));
	}

	//**保存键值对，可指定过期时间
	void put(String name, byte[] key, byte[] value, @Nullable Duration ttl);

	//**根据key获取value
	byte[] get(String name, byte[] key);

	//**如果键值对不存在则保存，返回缓存中当前的value
	byte[] putIfAbsent(String name, byte[] key, byte[] value, @Nullable Duration ttl);

	//**删除键值对
	void remove(String name, byte[] key);

	//**清除符合正则的缓存
	void clean(String name, byte[] pattern);
}

• DefaultRedisCacheWriter
  • DefaultRedisCacheWriter是DefaultRedisCacheWriter接口唯一的实现类；
  • DefaultRedisCacheWriter是作用域为包内可见，用户无法创建，只能使用DefaultRedisCacheWriter接口提供的静态方法；
  • 如果sleepTime为Zero或者为负数，则不会加锁，否则在执行redis命令时会加锁，默认为Zero；

class DefaultRedisCacheWriter implements RedisCacheWriter {
    //**redis连接工厂
	private final RedisConnectionFactory connectionFactory;
	//**等待锁，在有锁时线程休眠sleepTime毫秒，然后重新获取锁。如果sleepTime为Zero或者为负数，则不会加锁，否则在执行redis命令时会加锁
	private final Duration sleepTime;

	//**设置键值对
	public void put(String name, byte[] key, byte[] value, @Nullable Duration ttl) {
		...
		//**获取到锁后执行
		execute(name, connection -> {
		     //**如果ttl有效，则保存键值对并设置有效期
			if (shouldExpireWithin(ttl)) {
				connection.set(key, value, Expiration.from(ttl.toMillis(), TimeUnit.MILLISECONDS), SetOption.upsert());
			} else {  //**否则，则保存键值对
				connection.set(key, value);
			}
			return "OK";
		});
	}

	//**如果键值对不存在则保存，返回缓存中当前的value
	public byte[] putIfAbsent(String name, byte[] key, byte[] value, @Nullable Duration ttl) {
        ...
        //**获取到锁后执行
		return execute(name, connection -> {
            //**如果需要加锁，则加锁
			if (isLockingCacheWriter()) {
				doLock(name, connection);
			}

			try {
			    //**键值对不存在时，设置键值对
				if (connection.setNX(key, value)) {
                    //**如果ttl有效，则设置有效期
					if (shouldExpireWithin(ttl)) {
						connection.pExpire(key, ttl.toMillis());
					}
					return null;
				}
                //**返回当前保存的值
				return connection.get(key);
			} finally {
                //**解锁
				if (isLockingCacheWriter()) {
					doUnlock(name, connection);
				}
			}
		});
	}

	//**清除符合正则的缓存
	public void clean(String name, byte[] pattern) {
        ...
        //**获取到锁后执行
		execute(name, connection -> {
            //**是否加锁成功
			boolean wasLocked = false;
			try {
                //**如果需要加锁，则加锁，并设置加锁成功
				if (isLockingCacheWriter()) {
					doLock(name, connection);
					wasLocked = true;
				}
                //**根据正则获取key
				byte[][] keys = Optional.ofNullable(connection.keys(pattern)).orElse(Collections.emptySet())
						.toArray(new byte[0][]);
                //**如果有配置的key，则全部删除
				if (keys.length > 0) {
					connection.del(keys);
				}
			} finally {
                //**如果加锁成功并且需要加锁，则解锁
				if (wasLocked && isLockingCacheWriter()) {
					doUnlock(name, connection);
				}
			}

			return "OK";
		});
	}

	//**加锁
	void lock(String name) {
		execute(name, connection -> doLock(name, connection));
	}

	//**解锁
	void unlock(String name) {
		executeLockFree(connection -> doUnlock(name, connection));
	}

    //**加锁
	private Boolean doLock(String name, RedisConnection connection) {
		return connection.setNX(createCacheLockKey(name), new byte[0]);
	}

    //**解锁
	private Long doUnlock(String name, RedisConnection connection) {
		return connection.del(createCacheLockKey(name));
	}

    //**检查是否加锁
	boolean doCheckLock(String name, RedisConnection connection) {
		return connection.exists(createCacheLockKey(name));
	}

	//**是否加锁
	private boolean isLockingCacheWriter() {
		return !sleepTime.isZero() && !sleepTime.isNegative();
	}

    //**执行redis命令(没有获取到锁时会一直等待，直到获取锁，然后执行redis命令)
	private  T execute(String name, Function callback) {
		RedisConnection connection = connectionFactory.getConnection();
		try {

			checkAndPotentiallyWaitUntilUnlocked(name, connection);
			return callback.apply(connection);
		} finally {
			connection.close();
		}
	}

    //**执行redis命令
	private void executeLockFree(Consumer callback) {
		RedisConnection connection = connectionFactory.getConnection();
		try {
			callback.accept(connection);
		} finally {
			connection.close();
		}
	}
    
    //**等待锁(有锁时线程休眠sleepTime毫秒，然后重新获取锁)
	private void checkAndPotentiallyWaitUntilUnlocked(String name, RedisConnection connection) {
		if (!isLockingCacheWriter()) {
			return;
		}
		try {
			while (doCheckLock(name, connection)) {
				Thread.sleep(sleepTime.toMillis());
			}
		} catch (InterruptedException ex) {
			// Re-interrupt current thread, to allow other participants to react.
			Thread.currentThread().interrupt();
			throw new PessimisticLockingFailureException(String.format("Interrupted while waiting to unlock cache %s", name),
					ex);
		}
	}

    //**ttl是否有有效
	private static boolean shouldExpireWithin(@Nullable Duration ttl) {
		return ttl != null && !ttl.isZero() && !ttl.isNegative();
	}

    //**根据name创建锁的key
	private static byte[] createCacheLockKey(String name) {
		return (name + "~lock").getBytes(StandardCharsets.UTF_8);
	}
}

• RedisCacheConfiguration
  • RedisCache可通过RedisCacheConfiguration配置常用选项；
  • RedisCacheConfiguration使用了建造者模式，由于RedisCacheConfiguration各项属性都为final，所以先初始化所有属性创建一个默认的对象，然后在每个初始化属性的方法中都是重新创建一个对象；
    • 创建示例：RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(60));

public class RedisCacheConfiguration {
    //**缓存有效期
	private final Duration ttl;
	//**是否缓存空值
	private final boolean cacheNullValues;
	//**key前缀计算器
	private final CacheKeyPrefix keyPrefix;
	//**是否使用前缀
	private final boolean usePrefix;
	
    //**key的序列化器，持有RedisSerializer的引用，key只能是string
	private final SerializationPair keySerializationPair;
	//**value的序列化器，持有RedisSerializer的引用，value可以是任意类型
	private final SerializationPair