2. 程式人生 > >Springboot整合redis切庫問題

Springboot整合redis切庫問題

阿新 • • 發佈：2018-12-16

切庫問題

由於工作業務需求，需要在單機redis中做切庫處理。一般來說，redis資料庫有16個數據庫，而且有對應的索引，分別為0-15，如下圖 在這裡插入圖片描述 目前的專案時Springboot2.0.5搭建的，當前已經有一個redis工具類了。但是不滿足需求，需要修改。

舊版RedisUtils

application.yml配置

spring:
  redis:
    open: true  # 是否開啟redis快取  true開啟   false關閉
    database: 0
    host: localhost
    port: 6379
    password:    # 密碼（預設為空）
    timeout: 6000ms  # 連線超時時長（毫秒）
    jedis:
      pool:
        max-active: 1000  # 連線池最大連線數（使用負值表示沒有限制）
        max-wait: -1ms      # 連線池最大阻塞等待時間（使用負值表示沒有限制）
        max-idle: 10      # 連線池中的最大空閒連線
        min-idle: 5       # 連線池中的最小空閒連線

redis配置類

@Configuration
public class RedisConfig {
    @Autowired
    private RedisConnectionFactory factory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }

RedisUtils

@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Resource(name="redisTemplate")
    private ValueOperations<String, String> valueOperations;
    @Resource(name="redisTemplate")
    private HashOperations<String, String, Object> hashOperations;
    @Resource(name="redisTemplate")
    private ListOperations<String, Object> listOperations;
    @Resource(name="redisTemplate")
    private SetOperations<String, Object> setOperations;
    @Resource(name="redisTemplate")
    private ZSetOperations<String, Object> zSetOperations;
    /**  預設過期時長，單位：秒 */
    public final static long DEFAULT_EXPIRE = 60 * 60 * 24;
    /**  不設定過期時長 */
    public final static long NOT_EXPIRE = -1;

    public void set(String key, Object value, long expire){
        valueOperations.set(key, toJson(value));
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    }

    public void set(String key, Object value){
        set(key, value, DEFAULT_EXPIRE);
    }

    public <T> T get(String key, Class<T> clazz, long expire) {
        String value = valueOperations.get(key);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value == null ? null : fromJson(value, clazz);
    }

    public <T> T get(String key, Class<T> clazz) {
        return get(key, clazz, NOT_EXPIRE);
    }

    public String get(String key, long expire) {
        String value = valueOperations.get(key);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value;
    }

    public String get(String key) {
        return get(key, NOT_EXPIRE);
    }

    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * Object轉成JSON資料
     */
    private String toJson(Object object){
        if(object instanceof Integer || object instanceof Long || object instanceof Float ||
                object instanceof Double || object instanceof Boolean || object instanceof String){
            return String.valueOf(object);
        }
        return JSON.toJSONString(object);
    }

    /**
     * JSON資料，轉成Object
     */
    private <T> T fromJson(String json, Class<T> clazz){
        return JSON.parseObject(json, clazz);
    }

Redis切面，用來控制redis開關

@Aspect
@Component
public class RedisAspect {
    private Logger logger = LoggerFactory.getLogger(getClass());
    //是否開啟redis快取  true開啟   false關閉
    @Value("${renren.redis.open}")
    private boolean open;

    @Around("execution(* io.renren.common.utils.RedisUtils.*(..))")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Object result = null;
        if(open){
            try{
                result = point.proceed();
            }catch (Exception e){
                logger.error("redis error", e);
                throw new RRException("Redis服務異常");
            }
        }
        return result;
    }

以上是最開始的redis工具，但是隻能在yml配置檔案中配置指定的庫，不能動態切庫。

首次嘗試

參照了這篇文章 spring-data-redis進行選庫操作 我自定義了redisTemplate,繼承StringRedisTemplate，然後重寫了protected RedisConnection方法，然後整合當前的工具類，做了一些修改。但是最後測試的時候報錯：

java.lang.UnsupportedOperationException: Selecting a new database not supported due to shared connection. Use separate ConnectionFactorys to work with multiple databases
	at org.springframework.data.redis.connection.lettuce.LettuceConnection.select(LettuceConnection.java:640)
	at com.xQuant.app.common.utils.RedisUtils.setDbIndex(RedisUtils.java:45)
	at com.xQuant.app.common.utils.RedisUtils.set(RedisUtils.java:49)
	at com.xQuant.app.common.utils.RedisUtils.set(RedisUtils.java:57)
	at com.xQuant.app.XQuantAppApplicationTests.contextLoads(XQuantAppApplicationTests.java:20)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.springframework.test.context.junit4.statements.RunBeforeTestExecutionCallbacks.evaluate(RunBeforeTestExecutionCallbacks.java:73)
	at org.springframework.test.context.junit4.statements.RunAfterTestExecutionCallbacks.evaluate(RunAfterTestExecutionCallbacks.java:83)
	at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:75)
	at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:86)
	at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:84)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:251)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:97)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
	at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:190)
	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:89)
	at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:41)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:541)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:763)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:463)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:209)

大概意思就是在共享連結情況下不能切換庫。

方案一，還是用RedisTemplate

同事在網上找到了一篇這個文章： Spring cloud 和 Spring Boot 升級到F版和2.x遇到的問題。 這裡面有提到遇到上面那個問題： 在這裡插入圖片描述 給出的解決方案是在例項化RedisTemplate時，不再注入RedisConnectionFactory，改為注入LettuceConnectionFactory ，並關閉共享連結。所以修改當前的redis配置和工具類: 修改後的Redis配置

@Configuration
public class RedisConfig {
	@Autowired
	private LettuceConnectionFactory factory;

	@Bean
	public RedisTemplate<String, Object> redisTemplate() {
		// 關閉共享連結
		factory.setShareNativeConnection(false);
		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
		redisTemplate.setKeySerializer(new StringRedisSerializer());
		redisTemplate.setHashKeySerializer(new StringRedisSerializer());
		redisTemplate.setHashValueSerializer(new StringRedisSerializer());
		redisTemplate.setValueSerializer(new StringRedisSerializer());
		redisTemplate.setConnectionFactory(factory);
		return redisTemplate;
	}

	@Bean
	public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
		return redisTemplate.opsForHash();
	}

	@Bean
	public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
		return redisTemplate.opsForValue();
	}

	@Bean
	public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
		return redisTemplate.opsForList();
	}

	@Bean
	public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
		return redisTemplate.opsForSet();
	}

	@Bean
	public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
		return redisTemplate.opsForZSet();
	}

主要修改了兩個地方，注入LettuceConnectionFactory ，關閉共享連結 修改後的RedisUtils

/**
 * Redis工具類
 * 
 * 封裝了物件和字串的存,取,刪除,設定過期時間操作. 所有操作可以指定資料庫索引. 存,取可以設定過期時間. 沒有設定預設過期時間,存值時儘量設定過期時間
 * 
 * @author chunhui.tan
 * @version 建立時間：2018年10月8日 下午3:31:00
 */
@Component
public class RedisUtils {
	@Autowired
	private RedisTemplate<String, Object> redisTemplate;
	@Autowired
	private ValueOperations<String, String> valueOperations;
	@Autowired
	private HashOperations<String, String, Object> hashOperations;
	@Autowired
	private ListOperations<String, Object> listOperations;
	@Autowired
	private SetOperations<String, Object> setOperations;
	@Autowired
	private ZSetOperations<String, Object> zSetOperations;
	/** 預設過期時長，單位：秒 */
	//public final static long DEFAULT_EXPIRE = 60 * 60 * 24;
	/** 不設定過期時長 */
	public final static long NOT_EXPIRE = -1;
	private final static Gson gson = new Gson();
	
	public RedisTemplate<String, Object> getRedisTemplate() {
		return redisTemplate;
	}

	/**
	 * 插入值-物件,指定資料庫索引,指定過期時間
	 * 
	 * @param key     鍵
	 * @param value   值
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @param expire  過期時間 單位：秒
	 */
	public void set(String key, Object value, Integer dbIndex, long expire) {
		// 選擇資料庫
		setDbIndex(dbIndex);
		valueOperations.set(key, toJson(value));
		if (expire != NOT_EXPIRE) {
			redisTemplate.expire(key, expire, TimeUnit.SECONDS);
		}
	}

	/**
	 * 插入值-物件
	 * 
	 * @param key     鍵
	 * @param value   值
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 */
	public void set(String key, Object value, Integer dbIndex) {
		set(key, value, dbIndex, NOT_EXPIRE);
	}

	/**
	 * 插入值-物件 ,預設0 index資料庫
	 * 
	 * @param key   鍵
	 * @param value 值
	 */
	public void set(String key, Object value) {
		set(key, value, 0, NOT_EXPIRE);
	}

	/**
	 * 獲取值-物件,指定資料庫索引,並設定過期時間
	 * 
	 * @param key     鍵
	 * @param clazz   位元組碼物件
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @param expire  過期時間 單位：秒
	 * @return
	 */
	public <T> T get(String key, Class<T> clazz, Integer dbIndex, long expire) {
		setDbIndex(dbIndex);
		String value = valueOperations.get(key);
		if (expire != NOT_EXPIRE) {
			redisTemplate.expire(key, expire, TimeUnit.SECONDS);
		}
		return value == null ? null : fromJson(value, clazz);
	}

	/**
	 * 取值-物件 指定資料庫索引
	 * 
	 * @param key     鍵
	 * @param clazz   位元組碼物件
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @return
	 */
	public <T> T get(String key, Class<T> clazz, Integer dbIndex) {
		return get(key, clazz, dbIndex, NOT_EXPIRE);
	}

	/**
	 * 取值-物件
	 * 
	 * @param key   鍵
	 * @param clazz 位元組碼物件
	 * @return
	 */
	public <T> T get(String key, Class<T> clazz) {
		return get(key, clazz, 0, NOT_EXPIRE);
	}

	/**
	 * 獲取值-字串,指定資料庫索引,設定過期時間
	 * 
	 * @param key     鍵
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @param expire  過期時間 單位：秒
	 * @return
	 */
	public String get(String key, Integer dbIndex, long expire) {
		setDbIndex(dbIndex);
		String value = valueOperations.get(key);
		if (expire != NOT_EXPIRE) {
			redisTemplate.expire(key, expire, TimeUnit.SECONDS);
		}
		return value;
	}

	/**
	 * 取值-字串,指定資料庫索引
	 * 
	 * @param key     鍵
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @return
	 */
	public String get(String key, Integer dbIndex) {
		return get(key, dbIndex, NOT_EXPIRE);
	}

	/**
	 * 取值-字串
	 * 
	 * @param key 鍵
	 * @return
	 */
	public String get(String key) {
		return get(key, 0, NOT_EXPIRE);
	}

	/**
	 * 刪除 指定資料庫索引
	 * 
	 * @param key     鍵
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 */
	public Boolean delete(String key, Integer dbIndex) {
		setDbIndex(dbIndex);
		return redisTemplate.delete(key);
	}

	/**
	 * 刪除
	 * 
	 * @param key 鍵
	 */
	public Boolean delete(String key) {
		return delete(key, 0);
	}

	/**
	 * 設定過期時間 ,指定資料庫索引
	 * 
	 * @param key     鍵
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @param expire  過期時間 單位：秒
	 */
	public void expire(String key, Integer dbIndex, int expire) {
		setDbIndex(dbIndex);
		if (expire != NOT_EXPIRE) {
			redisTemplate.expire(key, expire, TimeUnit.SECONDS);
		}
	}

	/**
	 * 設定過期時間
	 * 
	 * @param key    鍵
	 * @param expire 過期時間 單位：秒
	 */
	public void expire(String key, int expire) {
		expire(key, 0, expire);
	}

	/**
	 * Object轉成JSON資料
	 */
	private String toJson(Object object) {
		if (object instanceof Integer || object instanceof Long || object instanceof Float || object instanceof Double
				|| object instanceof Boolean || object instanceof String) {
			return String.valueOf(object);
		}
		return gson.toJson(object);

	}

	/**
	 * JSON資料，轉成Object
	 */
	private <T> T fromJson(String json, Class<T> clazz) {
		return gson.fromJson(json, clazz);

	}

	/**
	 * 設定資料庫索引
	 * 
	 * @param dbIndex
	 */
	private void setDbIndex(Integer dbIndex) {
		if (dbIndex == null || dbIndex > 15 || dbIndex < 0) {
			dbIndex = 0;
		}
		LettuceConnectionFactory jedisConnectionFactory = (LettuceConnectionFactory) redisTemplate
				.getConnectionFactory();
		jedisConnectionFactory.setDatabase(dbIndex);
		redisTemplate.setConnectionFactory(jedisConnectionFactory);
	}

主要修改的了部分方法的引數，增加資料庫選擇。同事增加了選擇資料庫方法。

測試1

@RunWith(SpringRunner.class)
@SpringBootTest
public class XquantXcrmsApplicationTests {
	
	@Autowired
	private RedisUtils redisUtils;
	

	@Test
	public void contextLoads() {
		List<String> list = new ArrayList<>();
		list.add("2333");
		list.add("test1");
		this.redisUtils.set("哈哈哈", list, 11);
		System.out.println(redisUtils.getRedisTemplate().getConnectionFactory().getConnection());
		List<String> result = this.redisUtils.get("哈哈哈", List.class, 12);
		System.out.println(redisUtils.getRedisTemplate().getConnectionFactory().getConnection());
		System.out.println(result);
	}
}

分別為往11號庫存一次，然後再從12號庫去一次。 執行結果如下：

2018-10-18 18:50:36.203  INFO 11456 --- [           main] io.lettuce.core.KqueueProvider           : Starting without optional kqueue library
org.springf[email protected]b01cb8d
org.[email protected]38c460e8
---------------------------------
org.springf[email protected]b01cb8d
org.[email protected]4e67cfe1
null

修改測試程式碼如下

@RunWith(SpringRunner.class)
@SpringBootTest
public class XquantXcrmsApplicationTests {
	
	@Autowired
	private RedisUtils redisUtils;
	

	@Test
	public void contextLoads() {
		List<String> list = new ArrayList<>();
		list.add("2333");
		list.add("test1");
		this.redisUtils.set("哈哈哈", list, 12);
		System.out.println(redisUtils.getRedisTemplate().getConnectionFactory());
		System.out.println(redisUtils.getRedisTemplate().getConnectionFactory().getConnection());
		System.out.println("---------------------------------");
		List<String> result = this.redisUtils.get("哈哈哈", List.class, 11);
		System.out.println(redisUtils.getRedisTemplate().getConnectionFactory());
		System.out.println(redisUtils.getRedisTemplate().getConnectionFactory().getConnection());
		System.out.println(result);
	}
}

結果

2018-10-18 18:53:02.036  INFO 12524 --- [           main] io.lettuce.core.KqueueProvider           : Starting without optional kqueue library
org.springf[email protected]685d7ba5
org.[email protected]16d41725
---------------------------------
org.springf[email protected]685d7ba5
org.[email protected]4df7d9ee
[2333, test1]

觀察redis客戶端 在這裡插入圖片描述 在這裡插入圖片描述 測試沒有問題

方案二，用Jedis來實現

實際上用原生的Jedis也是可以實現切庫的。 yml檔案配置：

spring:
  redis:
    host: localhost
    port: 6379
    password: 
    timeout: 6000ms
    jedis:
      pool:
        max-active: 1000  # 連線池最大連線數（使用負值表示沒有限制）
        max-wait: -1ms      # 連線池最大阻塞等待時間（使用負值表示沒有限制）
        max-idle: 10      # 連線池中的最大空閒連線
        min-idle: 5       # 連線池中的最小空閒連線

Jedis配置類

/**
 * @author chunhui.tan
 * @version 建立時間：2018年10月18日 下午1:42:59
 *
 */
@Configuration
public class JedisConfiguration {
	
	/**
	 * 注入spirng中的讀取redis配置的類
	 */
	@Autowired
	private RedisProperties properties;

	@Bean
	public JedisPool getJedisPool() {
		JedisPoolConfig config = new JedisPoolConfig();
		config.setMaxIdle(properties.getJedis().getPool().getMaxIdle());
		config.setMaxTotal(properties.getJedis().getPool().getMaxActive());
		config.setMaxWaitMillis(properties.getJedis().getPool().getMaxWait().toMillis());
		JedisPool pool = new JedisPool(config, properties.getHost(), properties.getPort(),
				Integer.valueOf(Long.toString(properties.getTimeout().getSeconds())));
		return pool;
	}

}

Jedis工具類

/**
 * @author chunhui.tan
 * @version 建立時間：2018年10月18日 下午2:31:35
 *
 */
@Component
public class RedisUtils {

	@Autowired
	private JedisPool jedisPool;

	/** 不設定過期時長 */
	public final static int NOT_EXPIRE = -1;

	private final static Gson gson = new Gson();

	/**
	 * 插入值-物件,指定資料庫 指定過期時間
	 * 
	 * @param key     鍵
	 * @param value   值
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @param expire  過期時間 單位：秒
	 */
	public void set(String key, Object value, Integer dbIndex, int expire) {
		Jedis jedis = getJedis(dbIndex);
		jedis.set(key, toJson(value));
		if (expire != NOT_EXPIRE) {
			jedis.expire(key, expire);
		}
	}

	/**
	 * 插入值-物件,指定資料庫索引
	 * 
	 * @param key     鍵
	 * @param value   值
	 * @param dbIndex 資料庫索引 範圍 0-15,預設0
	 */
	public void set(String key, Object value, Integer dbIndex) {
		set(key, value, dbIndex, NOT_EXPIRE);
	}

	/**
	 * 插入值-物件 ,預設0 index資料庫
	 * 
	 * @param key   鍵
	 * @param value 值
	 */
	public void set(String key, Object value) {
		set(key, value, 0, NOT_EXPIRE);
	}

	/**
	 * 獲取值-物件,指定資料庫索引,並設定過期時間
	 * 
	 * @param key     鍵
	 * @param clazz   位元組碼物件
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @param expire  過期時間 單位：秒
	 * @return
	 */
	public <T> T get(String key, Class<T> clazz, Integer dbIndex, int expire) {
		Jedis jedis = getJedis(dbIndex);
		try {
			String value = jedis.get(key);
			if (expire != NOT_EXPIRE) {
				jedis.expire(key, expire);
			}
			return value == null ? null : fromJson(value, clazz);
		} finally {
			jedis.close();
		}
	}

	/**
	 * 取值-物件 指定資料庫索引
	 * 
	 * @param key     鍵
	 * @param clazz   位元組碼物件
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @return
	 */
	public <T> T get(String key, Class<T> clazz, Integer dbIndex) {
		return get(key, clazz, dbIndex, NOT_EXPIRE);
	}

	/**
	 * 取值-物件
	 * 
	 * @param key   鍵
	 * @param clazz 位元組碼物件
	 * @return
	 */
	public <T> T get(String key, Class<T> clazz) {
		return get(key, clazz, 0, NOT_EXPIRE);
	}

	/**
	 * 取值-字串,指定資料庫索引,設定過期時間
	 * 
	 * @param key     鍵
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @param expire  過期時間 單位：秒
	 * @return
	 */
	public String get(String key, Integer dbIndex, int expire) {
		Jedis jedis = getJedis(dbIndex);
		try {
			String value = jedis.get(key);
			if (expire != NOT_EXPIRE) {
				jedis.expire(key, expire);
			}
			return value;
		} finally {
			jedis.close();
		}
	}

	/**
	 * 取值-字串,指定資料庫索引
	 * 
	 * @param key     鍵
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @return
	 */
	public String get(String key, Integer dbIndex) {
		return get(key, dbIndex, NOT_EXPIRE);
	}

	/**
	 * 取值-字串
	 * 
	 * @param key 鍵
	 * @return
	 */
	public String get(String key) {
		return get(key, 0, NOT_EXPIRE);
	}

	/**
	 * 刪除 指定資料庫索引
	 * 
	 * @param key     鍵
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 */
	public void delete(String key, Integer dbIndex) {
		Jedis jedis = getJedis(dbIndex);
		try {
			jedis.del(key);
		} finally {
			jedis.close();
		}
	}

	/**
	 * 刪除
	 * 
	 * @param key 鍵
	 */
	public void delete(String key) {
		delete(key, 0);
	}

	/**
	 * 設定過期時間
	 * 
	 * @param key     鍵
	 * @param dbIndex 資料庫索引 範圍 0-15 預設0
	 * @param expire  過期時間 單位：秒
	 */
	public void expire(String key, Integer dbIndex, int expire) {
		Jedis jedis = getJedis(dbIndex);
		try {
			if (expire != NOT_EXPIRE) {
				jedis.expire(key, expire);
			}
		} finally {
			jedis.close();
		}
	}

	/**
	 * 設定過期時間
	 * 
	 * @param key    鍵
	 * @param expire 過期時間 單位：秒
	 */
	public void expire(String key, int expire) {
		expire(key, 0, expire);
	}

	/**
	 * 獲取jedis物件，並指定dbIndex
	 * 
	 * @param dbIndex
	 */
	private Jedis getJedis(Integer dbIndex) {
		Jedis jedis = jedisPool.getResource();
		if (dbIndex == null || dbIndex > 15 || dbIndex < 0) {
			dbIndex = 0;
		}
		jedis.select(dbIndex);
		return jedis;
	}

	/**
	 * Object轉成JSON資料
	 */
	private String toJson(Object object) {
		if (object instanceof Integer || object instanceof Long || object instanceof Float || object instanceof Double
				|| object instanceof Boolean || object instanceof String) {
			return String.valueOf(object);
		}
		return gson.toJson(object);

	}

	/**
	 * JSON資料，轉成Object
	 */
	private <T> T fromJson(String json, Class<T> clazz) {
		return gson.fromJson(json, clazz);
	}

裡面的核心方法：

/**
	 * 獲取jedis物件，並指定dbIndex
	 * 
	 * @param dbIndex
	 */
	private Jedis getJedis(Integer dbIndex) {
		Jedis jedis = jedisPool.getResource();
		if (dbIndex == null || dbIndex > 15 || dbIndex < 0) {
			dbIndex = 0;
		}
		jedis.select(dbIndex);
		return jedis;
	}

即在通過注入的JedisPool獲取Jedis物件時，指定一下資料庫即可

測試2

情況redis，然後執行以下程式碼

@RunWith(SpringRunner.class)
@SpringBootTest
public class XquantTestApplicationTests {
	
	@Autowired
	private RedisUtils redisUtils;
	
	@Test
	public void contextLoads() {
		List<String> list = new ArrayList<>();
		list.add("2333");
		list.add("test1");
		this.redisUtils.set("哈哈哈", list, 12);
		
		System.out.println("---------------------------------");
		List<String> result = this.redisUtils.get("哈哈哈", List.class, 11);
		
		System.out.println(result);
	}

}

控制檯

---------------------------------
null

觀察redis資料庫： 在這裡插入圖片描述 然後再執行以下程式碼：

@RunWith(SpringRunner.class)
@SpringBootTest
public class XquantTestApplicationTests {
	
	@Autowired
	private RedisUtils redisUtils;
	
	@Test
	public void contextLoads() {
		List<String> list = new ArrayList<>();
		list.add("2333");
		list.add("test1");
		this.redisUtils.set("哈哈哈", list, 11);
		
		System.out.println("---------------------------------");
		List<String> result = this.redisUtils.get("哈哈哈", List.class, 12);
		
		System.out.println(result);
	}

}

控制檯

---------------------------------
[2333, test1]

觀察redis資料庫 在這裡插入圖片描述 測試沒有問題

總結

可能redis切庫在日常業務中用到的地方不多，但是我碰巧遇到了這樣的需求，而且在和同事一起研究了一下，他研究RedisTemplate，我研究Jedis,最後發現兩種方法都可以實現，故在此記錄一下。至於其中的效能差別，或者連結健康情況，還沒來得及測試和討論。

相關推薦

Springboot整合redis切庫問題

切庫問題 由於工作業務需求，需要在單機redis中做切庫處理。一般來說，redis資料庫有16個數據庫，而且有對應的索引，分別為0-15，如下圖 目前的專案時Springboot2.0.5搭建的，當前已經有一個redis工具類了。但是不滿足需求，需要修改。

springBoot整合Redis遇到的坑(擇庫)原始碼分析為什麼擇庫失敗

1.配置實現SpringBoot整合Redis(只需兩步) 1.最簡單的配置就是在application.propertity中配置 #cache指定快取型別 spring.cache.type=REDIS #data-redis spring.redis.database=15 spring.r

springboot整合redis——redisTemplate的使用

關系 img redis-cli redis 安裝 -i 進行 start 啟動 一、概述 　　相關redis的概述，參見Nosql章節 　　redisTemplate的介紹，參考：http://blog.csdn.net/ruby_one/article/detail

springboot整合redis緩存

springboot redis 使用springBoot添加redis緩存需要在POM文件裏引入 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>

【SpringBoot系列2】SpringBoot整合Redis

並且 nds key值 數據 配置數據源 eth ren core 成功 前言： 真的越來越喜歡SpringBoot了，這是SpringBoot學習系列之一。 正文： 1：首先在pom文件中添加依賴，記得是spring-boot-starter-data-redis,不是s

八、springboot整合redis

clu com figure pri alt pass oot wired 用戶登錄 整合Redis 一. 註解方式實現添加緩存 　　1.在pom.xml加入依賴 <!-- 配置使用redis啟動器 --> <dependency> <

SpringBoot整合Redis初實踐

取數據 redis服務器 公眾號 redis-cli 內存 將在 個數 img 代理 　　Redis是一個開源（BSD許可），內存存儲的數據結構服務器，可用作數據庫，高速緩存和消息隊列代理。 　　有時,為了提升整個網站的性能,在開發時會將經常訪問的數據進行緩存,這樣在調用這

SpringBoot整合Redis

結構 dep 實體類 final [] serialize value keys test 結構： pom引入依賴： <dependency> <groupId>org.springframework.b

SpringBoot整合redis的LBS功能

下面的程式碼實現了新增經緯度資料 和 搜尋經緯度資料的功能： import java.util.List; import com.longge.goods.dto.BuildingDto; import com.longge.goods.dto.BuildingLbsDto; /** * LBS

springboot整合redis實現快取

使用redis做快取整合起來並不難，在整合的時候一定要將show sql開啟，這樣才能測試你寫整合的redis快取是否成功了。首先，你需要在官網下載一個redis，然後啟動redis-server，預設埠是6379，啟動後的介面如下：   redis在springboot

SpringBoot整合Redis解決叢集共享快取問題

需求分析： 應用程式採用整合的方式部署在3臺伺服器上，每臺伺服器上應用請求同一臺資料庫伺服器，應用程式中獲取當前使用者資訊是從當前伺服器上選取的，當前臺傳送求後需在後臺修改當前使用者的相關屬性，然後查詢當前屬性下的一些資料資訊 產生問題： 採用整合的方式部署，會導致當前修改請

Redis詳解 - SpringBoot整合Redis，RedisTemplate和註解兩種方式的使用

本文主要講 Redis 的使用，如何與 SpringBoot 專案整合，如何使用註解方式和 RedisTemplate 方式實現快取。最後會給一個用 Redis 實現分散式鎖，用在秒殺系統中的案例。 更多 Redis 的實際運用場景請關注開源專案 coderiver 專案地址：github.com/cac

springboot-整合redis：做快取，做分散式共享session

springboot-整合redis：做快取，做分散式共享session 文章目錄 springboot-整合redis：做快取，做分散式共享session 1.redis應用場景 2配置 3.測試 完整

Springboot整合redis 《springboot學習四》

安裝Redis A: 開啟redis服務 redis網站官方並沒有windows版本，只有Microsoft Open Tech group 在 GitHub上開發了一個Win64的版本，地址為https://github.com/MicrosoftArchive/redis/r

springboot 整合redis 做快取

  一、新增依賴jar包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-re

SpringBoot整合Redis例項

前言 在本篇文章中將SpringBoot整合Redis，使用的是RedisTemplate，分別實現了SpringBoot與redis的單機版、叢集版、哨兵模式的整合。 Maven依賴 <!-- 整合redis --> <dependency&g

深入理解Redis系列之SpringBoot整合Redis

SpringBoot環境 快速搭建一個SpringBoot工程 進入 https://start.spring.io 網站, 使用該網站初始化一個SpringBoot工程 新增相關依賴 因為使用spring initializer已經幫我們把Redis的依賴建立好了; 但是

springboot整合redis，實現session共享

   一直對serssion的共享有著很大的疑惑，對於我現在的工作的地方，所在的部門，因為沒有前臺頁面，純屬後臺。所以，不會存在session的共享問題。但是出於好奇，也是心裡的疑惑，今天也動手實驗了下。      

SpringBoot 2.0 | SpringBoot 整合 Redis + Cache + 分散式 Session

簡介 1.Redis redis是一個key-value儲存系統。它支援儲存的value型別相對更多，包括string(字串)、list(連結串列)、set(集合) 和hash（雜湊型別）。這些資料型別都支援push/pop、add/remove及取交集並集和差集及更豐富的操作，

springboot整合redis實現訊息佇列

在java中直接使用redis的時候，直接使用簡單的兩個指令lpush和rpop或者rpush和lpop就可以實現訊息佇列的操作。當與spring結合時，可以使用RedisTemplate和StringRedisTemplate；這兩個Template是spring封裝了對Redis的一些常用的