Here, I use the jar package spring boot starter data redis of redisTemplate combined with spring boot framework, which is introduced in the way of POM. The introduction code is as follows:
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.6.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
RedisTemplate mainly supports String, list, hash, set and Zset parameters. The corresponding methods are opsForValue(), opsForList(), opsForHash(), opsForSet(), opsForZSet(). The following describes the use of these methods.
Before introducing, let's first talk about the serialization method of RedisTemplate. Under the RedisTemplate class, there is a StringRedisTemplate class that inherits this class. This class is mainly used for the implementation of String type of opsForValue() method, and the internal implementation of these two classes is different. If RedisTemplate class is used as a tool class for connecting Redis, if opsForValue method is not used, We can initialize the serialization method as follows:
ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jackson2JsonRedisSerializer.setObjectMapper(om); template.setKeySerializer(template.getStringSerializer()); template.setValueSerializer(jackson2JsonRedisSerializer); template.setHashValueSerializer(jackson2JsonRedisSerializer);
If we need to use opsForValue() method, we must use the following serialization method:
ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jackson2JsonRedisSerializer.setObjectMapper(om); //Use this to change the serialization method when using the String data structure RedisSerializer<String> stringSerializer = new StringRedisSerializer(); template.setKeySerializer(stringSerializer ); template.setValueSerializer(stringSerializer ); template.setHashKeySerializer(stringSerializer ); template.setHashValueSerializer(stringSerializer );
Of course, if you want to use the RedisTemplate method as a bean, you must implement the code in the following way (all described here are used by using spring boot):
1. We can use * application The properties * file defines the following * redis * connection *:*
#Configure cache redis spring.redis.database=8 # Redis server address spring.redis.host=127.0.0.1 # Redis server connection port spring.redis.port=6379 # Redis server connection password (blank by default) spring.redis.password= # Maximum number of connections in connection pool (negative value indicates no limit) spring.redis.pool.max-active=8 # Maximum blocking waiting time of connection pool (negative value indicates no limit) spring.redis.pool.max-wait=-1 # Maximum free connections in connection pool spring.redis.pool.max-idle=8 # Minimum free connections in connection pool spring.redis.pool.min-idle=0 # Connection timeout (MS) spring.redis.keytimeout=1000 spring.redis.timeout=0
2. Use RedisTemplate class to set bean file:
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
/**
* @author liaoyubo
* @version 1.0 2017/8/1
* @description
*/
@Configuration
public class RedisConfig {
@Value("${spring.redis.host}")
private String hostName;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.password}")
private String passWord;
@Value("${spring.redis.pool.max-idle}")
private int maxIdl;
@Value("${spring.redis.pool.min-idle}")
private int minIdl;
@Value("${spring.redis.database}")
private int database;
@Value("${spring.redis.keytimeout}")
private long keytimeout;
@Value("${spring.redis.timeout}")
private int timeout;
/*@Bean
public JedisConnectionFactory redisConnectionFactory() {
JedisConnectionFactory factory = new JedisConnectionFactory();
factory.setHostName(hostName);
factory.setPort(port);
factory.setTimeout(timeout); //Set connection timeout
return factory;
}
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate(factory);
setSerializer(template); //Set the serialization tool so that the ReportBean does not need to implement the Serializable interface
template.afterPropertiesSet();
return template;
}
private void setSerializer(StringRedisTemplate template) {
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);
template.setValueSerializer(jackson2JsonRedisSerializer);
}*/
@Bean
public RedisConnectionFactory redisConnectionFactory(){
JedisPoolConfig poolConfig=new JedisPoolConfig();
poolConfig.setMaxIdle(maxIdl);
poolConfig.setMinIdle(minIdl);
poolConfig.setTestOnBorrow(true);
poolConfig.setTestOnReturn(true);
poolConfig.setTestWhileIdle(true);
poolConfig.setNumTestsPerEvictionRun(10);
poolConfig.setTimeBetweenEvictionRunsMillis(60000);
JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(poolConfig);
jedisConnectionFactory.setHostName(hostName);
if(!passWord.isEmpty()){
jedisConnectionFactory.setPassword(passWord);
}
jedisConnectionFactory.setPort(port);
jedisConnectionFactory.setDatabase(database);
return jedisConnectionFactory;
}
@Bean
public RedisTemplate<String, Object> redisTemplateObject() throws Exception {
RedisTemplate<String, Object> redisTemplateObject = new RedisTemplate<String, Object>();
redisTemplateObject.setConnectionFactory(redisConnectionFactory());
setSerializer(redisTemplateObject);
redisTemplateObject.afterPropertiesSet();
return redisTemplateObject;
}
private void setSerializer(RedisTemplate<String, Object> template) {
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
/*template.setKeySerializer(template.getStringSerializer());
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashValueSerializer(jackson2JsonRedisSerializer);*/
//Use this to change the serialization method when using the String data structure
RedisSerializer<String> stringSerializer = new StringRedisSerializer();
template.setKeySerializer(stringSerializer );
template.setValueSerializer(stringSerializer );
template.setHashKeySerializer(stringSerializer );
template.setHashValueSerializer(stringSerializer );
}
}
3. Create startup App class
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class App {
public static void main(String [] args){
SpringApplication.run(App.class);
}
}
Through the above steps, we can normally use redistemplate template template class by bean injection *. If redis * * is not installed, please go to https://redis.io/download Redis required for downloading on the official website. The following mainly introduces the redistemplate collection and the use of pipeline and multi in turn. The official website address is http://docs.spring.io/spring-data/redis/docs/current/api/org/springframework/data/redis/core/RedisTemplate.html . The method of injecting redistemplate is as follows** 😗
@Autowired private RedisTemplate<String,Object> redisTemplate;
1, pipeline * * introduction
Pipeline is a channel function provided by redis. Usually, when you use pipeline without waiting for the results to return immediately, the advantage of using pipeline is that it can process data faster, because it specially opens up a pipeline to process data (for specific comparison, please refer to online articles) * *. It is one-way, sending data from the client to the server, When the pipeline closes the link, the data will be returned from the server, and the data of the server cannot be obtained during the next time.
For the needs of this example, we put redisconfig The serialization method of Java class is modified as follows:
template.setKeySerializer(template.getStringSerializer()); template.setValueSerializer(jackson2JsonRedisSerializer); template.setHashValueSerializer(jackson2JsonRedisSerializer);
The following is a basic example:
import com.springRedis.App;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class PipelineTest {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
@Test
public void testPipeLine(){
redisTemplate.opsForValue().set("a",1);
redisTemplate.opsForValue().set("b",2);
redisTemplate.executePipelined(new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
redisConnection.openPipeline();
for (int i = 0;i < 10;i++){
redisConnection.incr("a".getBytes());
}
System.out.println("a:"+redisTemplate.opsForValue().get("a"));
redisTemplate.opsForValue().set("c",3);
for(int j = 0;j < 20;j++){
redisConnection.incr("b".getBytes());
}
System.out.println("b:"+redisTemplate.opsForValue().get("b"));
System.out.println("c:"+redisTemplate.opsForValue().get("c"));
redisConnection.closePipeline();
return null;
}
});
System.out.println("b:"+redisTemplate.opsForValue().get("b"));
System.out.println("a:"+redisTemplate.opsForValue().get("a"));
}
}
2, multi and * * exec
These two methods are redistemplate Transaction methods provided by Java classes. Before using this method, the transaction must be started for normal use. Examples are as follows:
import com.springRedis.App;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class MultiTest {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
@Test
public void testMulti(){
ValueOperations<String,Object> valueOperations = redisTemplate.opsForValue();
redisTemplate.setEnableTransactionSupport(true);
//You can't get the value before submitting, and the error is reported again
while (true){
redisTemplate.watch("multiTest");
redisTemplate.multi();
valueOperations.set("multiTest",1);
valueOperations.increment("multiTest",2);
Object o = valueOperations.get("multiTest");
List list = redisTemplate.exec();
System.out.println(list);
System.out.println(o);
}
}
}
* when using the * * exec() * * method, no parameters are brought in. The default serialization method is used, and a exec (RedisSerializer valueSerializer) method. This method can define its own serialization method, such as ` Jackson2JsonRedisSerializer.
The use of RedisTemplate collection will be introduced later.