源码github地址:
- 1、引入redis框架,当然版本需要和springboot的版本一致
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.0.4.RELEASE</version>
</dependency>
- 2、配置application.yml
目前是配置的单机
spring:
redis:
database: 0
password: 123456
host: localhost
port: 6379
jedis:
pool:
max-idle: 100
min-idle: 1
max-active: 300
max-wait: -1
- 3、配置redis缓存管理器,和redis模板
package com.org.springboot.serve.redis;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
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.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* Redis config files
*
* @Author: Tonny
* @CreateDate: 18/11/19 下午 03:33
* @Version: 1.0
*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
/**
* 生成key的策略
*
* @return
*/
@Bean
public KeyGenerator keyGenerator() {
return (target, method, params) -> {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
};
}
/**
* 缓存管理器
*
* @param connectionFactory
* @return CacheManager
*/
@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
//初始化一个RedisCacheWriter
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);
RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
// springboot2.0需要在缓存管理的时候对key和value进行序列化操作
// springboot1.0可以不用下面3行
RedisSerializer redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer serializer = this.getSerializer();
RedisCacheConfiguration redisCacheConfiguration = defaultCacheConfig
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));
//设置默认超过期时间是1000秒
// defaultCacheConfig.entryTtl(Duration.ofSeconds(1000));
//初始化RedisCacheManager
RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
return cacheManager;
}
/**
* 序列化key和value,防止乱码
* @return
*/
private Jackson2JsonRedisSerializer getSerializer() {
// 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值(默认使用JDK的序列化方式)
Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper mapper = new ObjectMapper();
// 指定要序列化的域,field,get和set,以及修饰符范围,ANY是都有包括private和public
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// 指定序列化输入的类型,类必须是非final修饰的,final修饰的类,比如String,Integer等会跑出异常
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(mapper);
return serializer;
}
/**
* RedisTemplate配置
*
* @param factory redis工厂
* @return RedisTemplate
*/
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate(factory);
RedisSerializer stringSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer serializer = this.getSerializer();
// 值采用json序列化
// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(stringSerializer);
template.setValueSerializer(serializer);
// 设置hash key 和value序列化模式
template.setHashKeySerializer(stringSerializer);
template.setHashValueSerializer(serializer);
template.afterPropertiesSet();
return template;
}
}
上述redis的基础配置就配置完了
下面我们来实际查询试试
- 4、实体类,DAO,Service,Test
一定需要继承Serializable
@Data
public class User implements Serializable {
private String id;
private String name;
private String age;
}
dao文件
public interface UserDao {
User getById(Long id);
List<User> getAll();
int updateUser(User user);
int deleteById(Long id);
int insert(User user);
}
mapper文件
<select id="getAll" resultMap="getMap">
select * from user
</select>
<select id="getById" resultType="com.org.springboot.entity.User"
parameterType="long">
select * from user where id = #{0}
</select>
<update id="updateUser" parameterType="com.org.springboot.entity.User">
update user set name = #{name},age = #{age} where id = #{id}
</update>
<delete id="deleteById" parameterType="long">
delete from user where id = #{0}
</delete>
<insert id="insert" parameterType="com.org.springboot.entity.User"
useGeneratedKeys="true" keyProperty="id" keyColumn="id">
INSERT INTO user (name, age) VALUES (#{name}, #{age});
</insert>
service实现了,当然还有借口类,我就不贴出来了
package com.org.springboot.service.impl;
import com.org.springboot.dao.UserDao;
import com.org.springboot.entity.User;
import com.org.springboot.serve.redis.RedisService;
import com.org.springboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
@Override
public List<User> getAll() {
return userDao.getAll();
}
@Override
@Cacheable(value = "User", key = "'user'.concat(#id.toString())")
public User getById(Long id) {
return userDao.getById(id);
}
@Override
@CachePut(value = "User", key = "'user'.concat(#user.id.toString())")
public User updateUser(User user) {
userDao.updateUser(user);
return user;
}
@Override
@CacheEvict(value = "User", key = "'user'.concat(#id.toString())")
public int deleteById(Long id) {
return userDao.deleteById(id);
}
@Override
@CachePut(value = "User", key = "'user'.concat(#user.id.toString())")
public User add(User user) {
userDao.insert(user);
return user;
}
/**
* keyGenerator策略生产key
*
* @param param1
* @param param2
* @return
*/
@Cacheable(value = "redis", key = "#p0")
@Override
public String cacheKeyGenerator(String param1, String param2) {
String str = param2;
return str;
}
}
- 5、单元测试类
package com.org.springboot.test;
import com.alibaba.fastjson.JSONObject;
import com.org.springboot.SpringbootApplication;
import com.org.springboot.entity.User;
import com.org.springboot.service.UserService;
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.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootApplication.class)
public class UserTest {
@Autowired
private UserService service;
@Test
public void getAll() {
List<User> list = service.getAll();
System.out.println(JSONObject.toJSONString(list));
}
@Test
public void add() {
User user = new User();
user.setName("王四");
user.setAge(3);
user = service.add(user);
System.out.println(JSONObject.toJSONString(user));
}
@Test
public void getById() {
User user = service.getById(1L);
System.out.println(JSONObject.toJSONString(user));
}
@Test
public void updateUser() {
int result = service.deleteById(1L);
System.out.println(result);
}
}
6、测试
先看redis里面的key为空
127.0.0.1:6379> keys *
127.0.0.1:6379>
执行add()添加方法:
程序控制台返回结果:{"age":3,"id":1,"name":"王四"}
==========================================
redis控制台:
==========================================
127.0.0.1:6379> keys *
127.0.0.1:6379> keys *
User::user1
127.0.0.1:6379> get User::user1
{"id":1,"name":"王四","age":3}
127.0.0.1:6379>