SpringBoot整合
java代码操作Redis ,需要使用Jedis,也就是redis支持java的第三方类库
注意:Jedis2.7以上的版本才支持集群操作
maven 配置
新建SpringBoot2.0以上的WEB工程在pom.xml文件中加
配置文件配置
spring:
redis:
port: 6379
password: rzkruizhukai123.
host: 47.***
lettuce:
pool:
max-active: 10 #最大连接数
max-idle: 6 #最大空闲数
min-idle: 2 #最小空闲数
max-wait: 1000
timeout: 2000 #连接
RedisConfig
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.net.UnknownHostException;
/**
* fileName:RedisConfig
* description:
* author:rzk
* createTime:2020/6/28 10:05
* versioni:1.0.0
*/
@Configuration
public class RedisConfig {
//自己定义一个RedisTemplate
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
throws UnknownHostException {
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
//Json序列化配置
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);
//String 的序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
//hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
//value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
//hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
实体类User
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable{
private String id;
private String name;
private Integer age;
}
UserServiceImpl
import com.rzk.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
/**
* fileName:UserServiceImpl
* description:
* author:rzk
* createTime:2020/7/17 9:36
* versioni:1.0.0
*/
@Service
@Slf4j
public class UserServiceImpl {
@Autowired
@Qualifier("redisTemplate")
private RedisTemplate redisTemplate;
/**
* Redis String 类型
* 需求: 用户输入一个 key
* 先判断Redis中是否存在该数据
*
* 如果存在,在Redis中进行查询,并返回
* 如果不存在,在MySQL数据库查询,将结果赋给Redis,并返回
*/
public String getString(String key){
System.out.println(redisTemplate);
return null;
}
测试-->整合完成
@SpringBootTest
class SpringbootLuttuceApplicationTests {
@Autowired
private UserServiceImpl userService;
@Test
void contextLoads() {
userService.getString("aaa");
}
}
使用RedisTemplate操作String类型
### UserServiceImpl
import com.rzk.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
/**
* fileName:UserServiceImpl
* description:
* author:rzk
* createTime:2020/7/17 9:36
* versioni:1.0.0
*/
@Service
@Slf4j
public class UserServiceImpl {
@Autowired
@Qualifier("redisTemplate")
private RedisTemplate redisTemplate;
/**
* Redis String 类型
* 需求: 用户输入一个 key
* 先判断Redis中是否存在该数据
*
* 如果存在,在Redis中进行查询,并返回
* 如果不存在,在MySQL数据库查询,将结果赋给Redis,并返回
*/
public String getString(String key){
if (redisTemplate.hasKey(key)){
log.info("-------------->Redis中查询出来:");
return (String) redisTemplate.opsForValue().get(key);
}else{
String val="RedisTemplate模板学习lettuce客户端";
log.info("MySQL中查询出来"+val);
redisTemplate.opsForValue().set(key,val);
log.info("-------------->在MySQL中查询出来的结果存入Redis中");
return val;
}
}
/**
* 测试String类型
*
*需求：用户输入一个redis数据，该key的有效期为28小时
*/
public void expireStr(String key,String value){
redisTemplate.opsForValue().set(key,value);//存进去
redisTemplate.expire(key,28, TimeUnit.HOURS);
}
测试
@SpringBootTest
class SpringbootLuttuceApplicationTests {
@Autowired
private UserServiceImpl userService;
@Test
void T1() {
String rzk = userService.getString("rzk");
System.out.println(rzk);
}
}
第一次查询
第二次就会从redis查询
使用key的有效期为28小时
UserServiceImpl
/**
* 测试String类型
*
*需求：用户输入一个redis数据，该key的有效期为28小时
*/
public void expireStr(String key,String value){
redisTemplate.opsForValue().set(key,value);//存进去
redisTemplate.expire(key,28, TimeUnit.HOURS);
}
使用Hash
UserServiceImpl
/**
* 测试Hash类型演示
* @param id
* @return
* 根据Id查询用户对象信息
* 先判断Redis中是否存在该key
* 如果不存在，查询数据库Mysql，并将结果添加到Redis中，并返回
* 如果存在，直接将结果在Redis查询，并返回
*/
public User selectById(String id){
// redisTemplate.hasKey()判断整个key是否存在
if(redisTemplate.opsForHash().hasKey("user",id)){
return (User)redisTemplate.opsForHash().get("user",id);
}else{
log.info("------->查询Mysql数据库");
User user = new User();
user.setId(id);
user.setName("rzk");
user.setAge(12);
/**
* @param h 用户实体 user
* @param hk 用户主键 id
* @param hv 整个对象
*/
redisTemplate.opsForHash().put("user",id,user);
return user;
}
}
第一次查询
第二次查询
