spring-data-redis -- 一次执行链路的分析

spring-redis 基于配置项的自动装载
redis 基于 bean 初始化的装载
spring-data-redis 的基本用法，事务的事项方式，等


spring:
  redis:
    host: 127.0.0.1
    password: xxxxx
    jedis:
      pool:
        max-wait:
    ....

1. 基本链接配置 database，url，host，passwrod 等
2. 客户端配置 jedis，Lettuce
3. 链接池配置 Pool	
4. 集群配置 （本文暂不做过多，后期加上）

public class StringRedisTemplate extends RedisTemplate<String, String> {
	/**
	 * Constructs a new <code>StringRedisTemplate</code> instance. {@link #setConnectionFactory(RedisConnectionFactory)}
	 * and {@link #afterPropertiesSet()} still need to be called.
	 */
	public StringRedisTemplate() {
		setKeySerializer(RedisSerializer.string());
		setValueSerializer(RedisSerializer.string());
		setHashKeySerializer(RedisSerializer.string());
		setHashValueSerializer(RedisSerializer.string());
	}
  .... 其余内容省略
	}
==========================================================
  
  RedisTemplate 内的 初始化操作
  
  @Override
	public void afterPropertiesSet() {
		super.afterPropertiesSet();
		boolean defaultUsed = false;
		if (defaultSerializer == null) {
			defaultSerializer = new JdkSerializationRedisSerializer(
					classLoader != null ? classLoader : this.getClass().getClassLoader());
		}
  }

  for (long i = 0; i < 1000; i++) {
            GoodsCache goodsCache = GoodsCache.builder().goodsId(i)
                    .storeId(1001L)
                    .build();
            stringRedisTemplate.opsForList().leftPush("goods:jdk", JSON.toJSONString(goodsCache));
        }

execute 系列操作 ，pipline，批量，事务等
公有redis 抽象命令，如 deletd，keys 等
opsForXXX 基于 redis 数据结构的封装 一些数据结构独特的命令用法，需要 先 转换为该对象之后，才可以进行执行
eg： (java doc) Returns the operations performed on list values.

abstract class ValueDeserializingRedisCallback implements RedisCallback<V> {
		private Object key;
		public ValueDeserializingRedisCallback(Object key) {
			this.key = key;
		}
		public final V doInRedis(RedisConnection connection) {
			byte[] result = inRedis(rawKey(key), connection);
			return deserializeValue(result);
		}
		@Nullable
		protected abstract byte[] inRedis(byte[] rawKey, RedisConnection connection);
	}

	@Override
	public Long leftPush(K key, V value) {
		byte[] rawKey = rawKey(key);
		byte[] rawValue = rawValue(value);
		return execute(connection -> connection.lPush(rawKey, rawValue), true);
	}
	 */
	@Override
	public V rightPop(K key) {
		return execute(new ValueDeserializingRedisCallback(key) {
			@Override
			protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
				return connection.rPop(rawKey);
			}
		}, true);
	}

@Override
	public Long rPush(byte[] key, byte[]... values) {
		Assert.notNull(key, "Key must not be null!");
		try {
			if (isPipelined()) {
				pipeline(connection.newJedisResult(connection.getRequiredPipeline().rpush(key, values)));
				return null;
			}
			if (isQueueing()) {
				transaction(connection.newJedisResult(connection.getRequiredTransaction().rpush(key, values)));
				return null;
			}
			return connection.getJedis().rpush(key, values);
		} catch (Exception ex) {
			throw convertJedisAccessException(ex);
		}
	}

	@Nullable
	public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
		Assert.isTrue(initialized, "template not initialized; call afterPropertiesSet() before using it");
		Assert.notNull(action, "Callback object must not be null");
	
    // 获取当前 的工厂实例，jedis or Lettuce等
		RedisConnectionFactory factory = getRequiredConnectionFactory();
		RedisConnection conn = null;
		try {
		 
      // 进行是否开启事务的传播
			if (enableTransactionSupport) {
				// only bind resources in case of potential transaction synchronization
				conn = RedisConnectionUtils.bindConnection(factory, enableTransactionSupport);
			} else {
				conn = RedisConnectionUtils.getConnection(factory);
			}
		
      // 事务相关处理
			boolean existingConnection = TransactionSynchronizationManager.hasResource(factory);
      // 获取链接
			RedisConnection connToUse = preProcessConnection(conn, existingConnection);
      // pipeline 相关处理
			boolean pipelineStatus = connToUse.isPipelined();
			if (pipeline && !pipelineStatus) {
				connToUse.openPipeline();
			}
			RedisConnection connToExpose = (exposeConnection ? connToUse : createRedisConnectionProxy(connToUse));
      
      // 具体的进行redis 操作执行，交由 最底层的 客户端封装层去执行
			T result = action.doInRedis(connToExpose);
			// close pipeline
			if (pipeline && !pipelineStatus) {
				connToUse.closePipeline();
			}
			// TODO: any other connection processing?
			return postProcessResult(result, connToUse, existingConnection);
		} finally {
      // 释放当前的链接资源
			RedisConnectionUtils.releaseConnection(conn, factory);
		}
	}