日志:117 评论:13
北京, 西城
【Java】RedisTemplate学习笔记

介绍

介绍

使用

依赖

加入下面的依赖项

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.1.7.RELEASE</version>
</dependency>
      	
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.3</version>
</dependency>

直接调用

我们可以通过代码直接调用 RedisTemplate

import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.core.RedisTemplate;

public class RedisController {
    
    public String Test() {
        RedisTemplate<String, String> redis = new RedisTemplate<String, String>();
        JedisConnectionFactory factory = new JedisConnectionFactory();
    	factory.setHostName("localhost");
    	factory.setPort(6379);
    	StringRedisSerializer ss = new StringRedisSerializer();
    	redis = new RedisTemplate();
    	redis.setConnectionFactory(factory);
    	redis.setKeySerializer(ss);
    	redis.setValueSerializer(ss);
    	redis.afterPropertiesSet();

        return redis.opsForValue().get("abc");
    }
}

配置

配置数据源

在 application.properties 设置配置项

##############################################################################
# redis
##############################################################################

spring.redis.host=localhost
spring.redis.port=6379

关闭自动配置

系统会自动载入默认数据源,建议关闭它

在 Application.java 里引入

import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

在 Application.java 的启动对象前面加上

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})

建立Redis控制器

我们建立一个用来通过RedisTemplate来连接redis的控制类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;
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.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

@Configuration
public class RedisConfigureController {
	
	@Bean(name = "redisDS")
	@Qualifier ("redisDS")
	public RedisConnectionFactory redisDS(
			@Value ("${spring.redis.host}") String hostName,
			@Value ("${spring.redis.port}") int port
			) {
		JedisConnectionFactory jf = new JedisConnectionFactory();
		jf.setHostName(hostName);
		jf.setPort(port);
		RedisConnectionFactory rf = jf;
		
		return rf;
	}
	
	@Bean(name = "redisRT")
	@Qualifier ("redisRT")
	public RedisTemplate<String, String> redisRT(
			@Qualifier ("redisDS") RedisConnectionFactory factory
			) {
		RedisTemplate<String, String> rt = new RedisTemplate<String, String>();
		rt.setConnectionFactory(factory);
		StringRedisSerializer ss = new StringRedisSerializer();
		rt.setKeySerializer(ss);
		rt.setValueSerializer(ss);
		rt.afterPropertiesSet();
		
		return rt;
	}
	
	@Bean(name = "redisRTO")
	@Qualifier ("redisRTO")
	public RedisTemplate<String, Object> redisRTO(
			@Qualifier ("redisDS") RedisConnectionFactory factory
			) {
		RedisTemplate<String, Object> rt = new RedisTemplate<String, Object>();
		rt.setConnectionFactory(factory);
		Jackson2JsonRedisSerializer<Object> jjs = new Jackson2JsonRedisSerializer<Object>(Object.class);
		StringRedisSerializer ss = new StringRedisSerializer();
		rt.setKeySerializer(ss);
		rt.setValueSerializer(jjs);
		rt.setHashKeySerializer(ss);
		rt.setHashValueSerializer(jjs);
		rt.setEnableDefaultSerializer(true);
		rt.setDefaultSerializer(jjs);
		
		return rt;
	}
}

在启动类里注入

我们需要在启动类里注入这个控制器的JdbcTemplate

然后通过参数的方式传递给逻辑对象Test

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;

import com.example.demo.controller.RedisConfigureController;
import com.example.demo.model.Test;

@RestController
public class TestController {
	
    @Autowired
    @Qualifier ("redisRT")
    RedisTemplate<String, String> redis;
    
    @Autowired
    @Qualifier ("redisRTO")
    RedisTemplate<String, Object> redis;
	
    @RequestMapping("/test")
    public Test dealTest(@RequestParam(value="name", defaultValue="World") String name) {
        Test test = new Test(redis);
        
        return test;
    }
}

实体User对象

我们建立一个实体User对象

public class User {

        private int uId;
        private String uName;
	
	public void setUId(int uId) {
		this.uId = uId;
	}
	
	public void setUName(String uName) {
		this.uName = uName;
	}
	
	public int getUId() {
		return this.uId;
	}
	
	public String getUName() {
		return this.uName;
	}
}

控制器Test对象

我们在Test对象里测试redis的字符串操作

import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import com.example.demo.entity.User;

@Configuration
public class Test {
	
	@Autowired
	@Qualifier ("mysqlJT")
	JdbcTemplate jdbc;
	
	@Autowired
	@Qualifier ("redisRT")
	RedisTemplate<String, String> redis;
	
	@Autowired
	@Qualifier ("redisRTO")
	RedisTemplate<String, Object> redisObj;
	
	public Test() {
	    
	}
	
	pubilc String testStringRedis() {
	    String test;
	    
	    test = "testValue";
	    redis.opsForValue().set("testKey", test);
	    test = redis.opsForValue().get("testKey");
	    
	    return test;
	}
	
	public User testObjectRedis () {
	    User user;
	    
	    user = new User();
	    user.setUId(123);
	    user.setUName("demo");
	    redisObj.setValueSerializer(new Jackson2JsonRedisSerializer<Member>(Member.class));
	    redisObj.opsForValue().set("testObject", user);
	    user = (User) redisObj.opsForValue().get("testObject");
	    
	    return user;
	}
}