In the era of WebServer, Jedis direct connection is mostly used in the code to operate Redis server, so people will package a tool class in the project for Jedis. However, in the era of microservice integration SpringBoot, letstructure (underlying Netty, NIO mode) is used. We only need to pay attention to the use of RedisTemplate, but there are two redistemplates by default in SpringBoot, One is the configured String Template (because there are many String types). If we want to use more data structures conveniently, we must mention another rough RedisTemplate provided by Spring - rough is because there is no targeted serialization inside, and the key is Object by default (which means we need to force it on this basis).
Therefore, the following two points will be done for the use of Redis in the work:
-
Customize a RedisTemplate - complete all targeted configurations of the RedisTemplate, and then hand over the RedisTemplate to Spring for management. (generally, it is used to specify the configuration of the Json serializer during the operation of each big data structure... With this customized RedisTemplate, Spring will load the customized RedisTemplate first by default, because the original RedisTemplate has the annotation @ ConditionalOnMissingBean(name = "RedisTemplate"), to the effect that if you customize the RedisTemplate and submit it to Spring for management, You will give priority to the config package defined by the company
-
Encapsulate a RedisUtils tool class - encapsulate our customized RedisTemplate into a tool class and use it in real development (in the era of WebServer, it is encapsulated for Jedis). This class has the calling operation of all data structures, which eliminates the need for us to Catch exceptions and other logical operations, making it a real tool for Redis operation in our daily work.
——Remember, after any company integrates SpringBoot, it will generally complete the above two points for Redis operation first. The name and other details may be slightly different, but they will never change.
The following are the specific steps of these two operations (you can directly copy them to the project for use. Of course, there are many similar configurations on Baidu, and you can also make fine adjustments according to your company's Redis version)
1, Customize RedisTemplate, which is managed by Spring
@Configuration
public class RedisConfig {
//RedisTemplate serialization configuration -- > note that @ Qualifier("redisTemplate") should be used to avoid ambiguity (there are use cases in the test class)
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
// For the convenience of our own development, we generally directly use < string, Object >
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
// Json serialization configuration
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// Serialization of String
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// The key adopts the serialization method of String
template.setKeySerializer(stringRedisSerializer);
// The key of hash is also serialized by String
template.setHashKeySerializer(stringRedisSerializer);
// value serialization adopts jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// The serialization mode of jackson value is adopted
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
2, Encapsulate the customized RedisTemplate into a RedisUtils and use it in daily projects
@Component
public final class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/**
* Specify cache expiration time
* @param key key
* @param time Time (seconds)
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Get expiration time according to key
* @param key Key cannot be null
* @return Time (seconds) returns 0, which means it is permanently valid
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* Determine whether the key exists
* @param key key
* @return true Exists false does not exist
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Delete cache
* @param key One or more values can be passed
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
// ============================String=============================
/**
* Normal cache fetch
* @param key key
* @return value
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* Normal cache put
* @param key key
* @param value value
* @return true Success false failure
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Normal cache put in and set time
* @param key key
* @param value value
* @param time Time (seconds) time should be greater than 0. If time is less than or equal to 0, the indefinite period will be set
* @return true Success false failure
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Increasing
* @param key key
* @param delta How many to add (greater than 0)
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("The increment factor must be greater than 0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* Diminishing
* @param key key
* @param delta How many to reduce (less than 0)
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("Decrement factor must be greater than 0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
* @param key Key cannot be null
* @param item Item cannot be null
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* Get all key values corresponding to hashKey
* @param key key
* @return Corresponding multiple key values
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
* @param key key
* @param map Corresponding to multiple key values
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet And set the time
* @param key key
* @param map Corresponding to multiple key values
* @param time Time (seconds)
* @return true Success false failure
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Put data into a hash table. If it does not exist, it will be created
*
* @param key key
* @param item term
* @param value value
* @return true Success false failure
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Put data into a hash table. If it does not exist, it will be created
*
* @param key key
* @param item term
* @param value value
* @param time Time (seconds): Note: if the existing hash table has time, the original time will be replaced here
* @return true Success false failure
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Delete values in hash table
*
* @param key Key cannot be null
* @param item Item can make multiple non null able
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* Judge whether there is the value of this item in the hash table
*
* @param key Key cannot be null
* @param item Item cannot be null
* @return true Exists false does not exist
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash If increment does not exist, it will create one and return the added value
*
* @param key key
* @param item term
* @param by How many to add (greater than 0)
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash Diminishing
*
* @param key key
* @param item term
* @param by To reduce (less than 0)
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* Get all the values in the Set according to the key
* @param key key
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* Query from a set according to value whether it exists
*
* @param key key
* @param value value
* @return true Exists false does not exist
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Put data into set cache
*
* @param key key
* @param values Values can be multiple
* @return Number of successes
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* Put set data into cache
*
* @param key key
* @param time Time (seconds)
* @param values Values can be multiple
* @return Number of successes
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0)
expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* Gets the length of the set cache
*
* @param key key
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* Remove with value
*
* @param key key
* @param values Values can be multiple
* @return Number of removed
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* Get the contents of the list cache
*
* @param key key
* @param start start
* @param end End 0 to - 1 represent all values
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* Gets the length of the list cache
*
* @param key key
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* Get the value in the list through the index
*
* @param key key
* @param index When index index > = 0, 0 header, 1 second element, and so on; When index < 0, - 1, footer, - 2, the penultimate element, and so on
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* Put the list into the cache
*
* @param key key
* @param value value
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Put the list into the cache
* @param key key
* @param value value
* @param time Time (seconds)
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Put the list into the cache
*
* @param key key
* @param value value
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Put the list into the cache
*
* @param key key
* @param value value
* @param time Time (seconds)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Modify a piece of data in the list according to the index
*
* @param key key
* @param index Indexes
* @param value value
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* Remove N values as value
*
* @param key key
* @param count How many to remove
* @param value value
* @return Number of removed
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
Finally, a great Redis command is recommended. Refer to the Chinese website: