spring-boot-note6---redis
SpringBoot整合Redis，本文采用RedisTemplate操作redis和配置CacheMannager使用缓存注解的二个方式。
一、配置相关
1、添加pom依赖
org.springframework.boot
spring-boot-starter-redis
2、application.properties
#redis配置
spring.redis.database=0
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=123456
#连接超时时间
spring.redis.timeout=2000
#连接池最大连接数(使用负值表示没有限制)
spring.redis.pool.max-active=500
#连接池最大阻塞等待时间(使用负值表示没有限制)
spring.redis.pool.max-wait=10000
#连接池中的最大空闲连接
spring.redis.pool.max-idle=50
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0包结构：
配置类详细：(1、配置redisTemplate可直接操作redis，2、配置CacheManager+@EnableCaching可以使用缓存注解)
@Configuration
@EnableCaching // 开启注解的方式
public class RedisConfig {
/**
* 1、设置CacheManager实现为redisCacheMannager,并且开启EnableCaching，可以使用缓存注解。
*/
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
rcm.setUsePrefix(true);
rcm.setCacheNames(Arrays.asList("myCache"));
rcm.setDefaultExpiration(600);
return rcm;
}
/**
* 2、redisTemplate配置完成可以直接使用redis
*/
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
RedisTemplate template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializer 二、使用redistemplate操作redis
1、pojo、dao等。
public class Person implements Serializable{
private static final long serialVersionUID = -3189329947019478591L;
private Integer id;
public String name;@Component
public class PersonDao {
private static Map map = new HashMap<>();
static {
Person p;
for (int i = 0; i < 10; i++) {
p = new Person();
p.setId(i);
p.setName("name" + i);
map.put(i, p);
}
}
public void deleteById(Integer id) {
map.remove(id);
}
public Person findById(Integer id) {
return map.get(id);
}
public void updateOne(Person person) {
Person old = map.get(person.getId());
old.setName(person.getName());
}
public void saveOne(Person person) {
map.put(person.getId(), person);
}
public List findList() {
return new ArrayList<>(map.values());
} 2、redisTemplate操作redis的service类
/**
* 使用redisTemplate操作缓存。
*/
@Service
public class PersonService {
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
private PersonDao personDao;
@Resource
private RedisTemplate redisTemplate;
/**
* 查找person
* 缓存存在从缓存中取，不存在，查询出放入缓存。
*/
public Person getById(int id) {
logger.info("获取用户start...");
String key = "person_" + id;
ValueOperations operations = redisTemplate.opsForValue();
boolean hasKey = redisTemplate.hasKey(key);
if (hasKey) {
Person user = operations.get(key);
logger.info("从缓存中获取了 id = " + id);
return user;
}
Person person = personDao.findById(id);
operations.set(key, person, 10, TimeUnit.SECONDS);
return person;
}
/**
* 更新用户
* 如果缓存存在，删除
* 如果缓存不存在，不操作
*/
public void updateUser(Person person) {
logger.info("更新用户start...");
personDao.updateOne(person);
String key = "person_" + person.getId();
boolean hasKey = redisTemplate.hasKey(key);
if (hasKey) {
redisTemplate.delete(key);
logger.info("更新时，删除缓存id= " + person.getId());
}
}
/**
* 删除用户
* 如果缓存中存在，删除
*/
public void deleteById(int id) {
logger.info("删除用户start...");
personDao.deleteById(id);
String key = "person_" + id;
boolean hasKey = redisTemplate.hasKey(key);
if (hasKey) {
redisTemplate.delete(key);
logger.info("删除时，从缓存中删除id=>> " + id);
}
}
} 3、测试使用。
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class TestPersonService {
@Autowired
private PersonService personService;
/**
* redis缓存使用redisTemplate操作的演示
*/
@Test
public void testCache() {
int id = 1;
Person person = personService.getById(id); // 第1次查询 //获取用户start...
Person person2 = personService.getById(id); // 第2次查询 //获取用户start...
//从缓存中获取了 id = 1
person2.setName("update_name");
personService.updateUser(person2); // 第1次更新 //更新用户start...
//更新时，删除缓存id= 1
Person person3 = personService.getById(id); // 第3次查询 //获取用户start...
System.out.println(person3.getName()); // update_name
personService.deleteById(id); // 第1次删除 // 删除用户start...
// 删除时，从缓存中删除id=>> 1
assertNull(personService.getById(id));
}
}三、使用缓存注解的方式。
@Service
public class PersonCacheService {
@Autowired
private PersonDao personDao;
/**
* 查询一个Person
*/
@Cacheable(value = "myCache", key = "'Persons_'+#id")
public Person findPerson(Integer id) {
Person person = this.personDao.findById(id);
System.out.println("数据库查一条记录:id=" + id);
return person;
}
/**
* 更新一个Person,每次都会执行。
*/
@CachePut(value="myCache", key="'Persons_'+#id")
public Person updatePerson(Person person,Integer id) {
this.personDao.updateOne(person);
System.out.println("数据库更新一条记录:id=" + id);
return person;
}
/**
* 删除一个Person
*/
@CacheEvict(value = "myCache", key = "'Persons_'+#id", condition = "#id!=99")
public void delPerson(Integer id) {
System.out.println("数据库删除一条记录:id=" + id);
this.personDao.deleteById(id);
}
}@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class TestPersonCacheService {
@Autowired
private PersonCacheService personCacheService;
@Test
public void test1() {
Person person1 = personCacheService.findPerson(1); // 数据库查一条记录:id=1
Person person2 = personCacheService.findPerson(1);
person2.setName("update_name");
personCacheService.updatePerson(person2, 1); //数据库更新一条记录:id=1
Person person3 = personCacheService.findPerson(1); // 不查询，@CachePut每次都会执行，并把结果放入缓存。
System.out.println(person3.getName()); //update_name
personCacheService.delPerson(1); // 数据库删除一条记录:id=1
}
}