Redisæ¯ä¸ä¸ªä½¿ç¨Cè¯è¨å¼åçå¼æºçåºäºå åçå¯æä¹ åçæ¥å¿åKVæ°æ®åºãå¨å®é å¼åè¿ç¨ä¸å¨å¾å¤å°æ¹é½ä¼ç¨å°Redisæ°æ®åºãä¸é¢æ们就æ¥çä¸ä¸å¨Spring Bootä¸å¦ä½æ´åRedisï¼æ¥å®ç°æ°æ®åå¨çæä½ã
å建项ç®
é¦å éè¦å建ä¸ä¸ªSpring Bootç项ç®ï¼å¹¶ä¸å¨é¡¹ç®ä¸å¼å ¥Redisç¸å ³çPOMä¾èµï¼å¦ä¸ã
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.79</version>
</dependency>
第äºæ¥ãéè¦å¨é ç½®æ件ä¸æ·»å å ³äºRedisçåºç¡è¿æ¥é ç½®ã
spring:
redis:
# å°å
host: 192.168.1.248
# 端å£ï¼é»è®¤ä¸º6379
port: 6379
# å¯ç
password:
# è¿æ¥è¶
æ¶æ¶é´
timeout: 10s
lettuce:
pool:
# è¿æ¥æ± ä¸çæå°ç©ºé²è¿æ¥
min-idle: 0
# è¿æ¥æ± ä¸çæ大空é²è¿æ¥
max-idle: 8
# è¿æ¥æ± çæ大æ°æ®åºè¿æ¥æ°
max-active: 8
# #è¿æ¥æ± æ大é»å¡çå¾
æ¶é´ï¼ä½¿ç¨è´å¼è¡¨ç¤ºæ²¡æéå¶ï¼
max-wait: -1ms
第ä¸æ¥ãæ·»å Redisç¸å ³çé 置类
@Configuration
@EnableCaching
public class RedisConfig {
@Bean
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
{
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(mapper);
template.setValueSerializer(serializer);
// 使ç¨StringRedisSerializeræ¥åºåååååºååredisçkeyå¼
template.setKeySerializer(new StringRedisSerializer());
template.afterPropertiesSet();
return template;
}
}
è¿éæ们å¼å ¥äºFastJsonä½ä¸ºRedisåºååçå·¥å ·æ¥è¿è¡å¯¹è±¡åå¨
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{
@SuppressWarnings("unused")
private ObjectMapper objectMapper = new ObjectMapper();
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private Class<T> clazz;
static
{
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
}
public FastJson2JsonRedisSerializer(Class<T> clazz)
{
super();
this.clazz = clazz;
}
@Override
public byte[] serialize(T t) throws SerializationException
{
if (t == null)
{
return new byte[0];
}
return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
}
@Override
public T deserialize(byte[] bytes) throws SerializationException
{
if (bytes == null || bytes.length <= 0)
{
return null;
}
String str = new String(bytes, DEFAULT_CHARSET);
return JSON.parseObject(str, clazz);
}
public void setObjectMapper(ObjectMapper objectMapper)
{
Assert.notNull(objectMapper, "'objectMapper' must not be null");
this.objectMapper = objectMapper;
}
protected JavaType getJavaType(Class<?> clazz)
{
return TypeFactory.defaultInstance().constructType(clazz);
}
}
RedisTemplateç使ç¨
å¨ä¸é¢çé ç½®æ件ä¸æ们å¾IOC容å¨ä¸æ³¨å ¥äºä¸ä¸ªRedisTemplateï¼è¿ä¸ªTemplateä¸ä¹åæ们è§å°è¿çJDBCTemplate类似ï¼å°±æ¯ç¨æ¥è¿è¡Redisè¿æ¥æä½çå·¥å ·ç±»ãè¿éæ们ç®åçæ¥çä¸ä¸RedisTemplateç使ç¨ã
å¦ä¸å¾æ示ï¼RedisTemplate为æ们æä¾äºå¾å¤çæ¯æ使ç¨Redisçæä½æ¥å£ï¼æ们å¯ä»¥éè¿è¿äºæ¥å£æ¥å®ç°å¯¹äºRedisç访é®ä¸ä½¿ç¨ãå½ç¶è¿éç»åºçæ¹æ³é½æ¯åºäºåºå±çä¸äºæä½ï¼ä¸ºäºæ¹ä¾¿å¨ä¸å±é»è¾ä¸ä½¿ç¨ï¼æ们ä¹å¯ä»¥å¯¹åºå±çRedisTemplateè¿è¡å°è£ æ¹ä¾¿æ们å¨ä¸å±é»è¾ä¸ä½¿ç¨ã
å°è£ RedisTemplate对äºRedisäºç§æ°æ®ç±»åçæä½
Redisä¸æä¾äºäºç§æ°æ®ç±»åçåå¨åå«æ¯String ãListãSetãZSetãHashãä¸é¢æ们就æ¥éè¿RedisTemplateæ¥å®ç°å¯¹äºè¿äºç§æ°æ®ç±»åçåºæ¬æä½ã代ç å¦ä¸
ç¼ååºæ¬ç对象ï¼IntegerãStringãå®ä½ç±»ç
/**
* ç¼ååºæ¬ç对象ï¼IntegerãStringãå®ä½ç±»ç
*
* @param key ç¼åçé®å¼
* @param value ç¼åçå¼
*/
public <T> void setCacheObject(final String key, final T value)
{
redisTemplate.opsForValue().set(key, value);
}
/**
* ç¼ååºæ¬ç对象ï¼IntegerãStringãå®ä½ç±»ç
*
* @param key ç¼åçé®å¼
* @param value ç¼åçå¼
* @param timeout æ¶é´
* @param timeUnit æ¶é´é¢ç²åº¦
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
{
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
设置æææ¶é´
/**
* 设置æææ¶é´
*
* @param key Redisé®
* @param timeout è¶
æ¶æ¶é´
* @return true=设置æåï¼false=设置失败
*/
public boolean expire(final String key, final long timeout)
{
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置æææ¶é´
*
* @param key Redisé®
* @param timeout è¶
æ¶æ¶é´
* @param unit æ¶é´åä½
* @return true=设置æåï¼false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit)
{
return redisTemplate.expire(key, timeout, unit);
}
è·å¾ç¼åçåºæ¬å¯¹è±¡
/**
* è·å¾ç¼åçåºæ¬å¯¹è±¡ã
*
* @param key ç¼åé®å¼
* @return ç¼åé®å¼å¯¹åºçæ°æ®
*/
public <T> T getCacheObject(final String key)
{
ValueOperations<String, T> operation = redisTemplate.opsForValue();
return operation.get(key);
}
å é¤æä½
/**
* å é¤å个对象
*
* @param key
*/
public boolean deleteObject(final String key)
{
return redisTemplate.delete(key);
}
/**
* å é¤éå对象
*
* @param collection å¤ä¸ªå¯¹è±¡
* @return
*/
public long deleteObject(final Collection collection)
{
return redisTemplate.delete(collection);
}
ç¼åListæ°æ®
/**
* ç¼åListæ°æ®
*
* @param key ç¼åçé®å¼
* @param dataList å¾
ç¼åçListæ°æ®
* @return ç¼åç对象
*/
public <T> long setCacheList(final String key, final List<T> dataList)
{
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
è·å¾ç¼åçlist对象
/**
* è·å¾ç¼åçlist对象
*
* @param key ç¼åçé®å¼
* @return ç¼åé®å¼å¯¹åºçæ°æ®
*/
public <T> List<T> getCacheList(final String key)
{
return redisTemplate.opsForList().range(key, 0, -1);
}
ç¼åSet
/**
* ç¼åSet
*
* @param key ç¼åé®å¼
* @param dataSet ç¼åçæ°æ®
* @return ç¼åæ°æ®ç对象
*/
public <T> long setCacheSet(final String key, final Set<T> dataSet)
{
Long count = redisTemplate.opsForSet().add(key, dataSet);
return count == null ? 0 : count;
}
/**
* è·å¾ç¼åçset
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key)
{
return redisTemplate.opsForSet().members(key);
}
ç¼åMap
/**
* ç¼åMap
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
{
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* è·å¾ç¼åçMap
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key)
{
return redisTemplate.opsForHash().entries(key);
}
å¾Hashä¸åå ¥æ°æ®
/**
* å¾Hashä¸åå
¥æ°æ®
*
* @param key Redisé®
* @param hKey Hashé®
* @param value å¼
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value)
{
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* è·åHashä¸çæ°æ®
*
* @param key Redisé®
* @param hKey Hashé®
* @return Hashä¸ç对象
*/
public <T> T getCacheMapValue(final String key, final String hKey)
{
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* è·åå¤ä¸ªHashä¸çæ°æ®
*
* @param key Redisé®
* @param hKeys Hashé®éå
* @return Hash对象éå
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
{
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
æ»ç»
ä¸é¢çä¾åï¼æ们ä»ç»äºåSpring Bootä¸å¦ä½æ´åRedisæ°æ®åºï¼å¹¶ä¸æ´åäºRedisTemplateä¸å¯¹Redisåå¨çäºç§åºæ¬æ°æ®ç±»åè¿è¡äºåºæ¬æä½å°è£ ãæ¥ä¸æ¥æ们å¯ä»¥ä½¿ç¨æ´åRedisæä½æ¥å®æå ³äºç¼åãåå¸å¼éçåºç¨çå®ç°ãå¸æ大家å¤å¤å ³æ³¨ï¼åç»è¿ä¼å¸¦æ¥æ´å¤å¹²æ´»å 容