springboot + redis缓存使用

【参照资料】

1.spring boot 官网文档

2.https://www.cnblogs.com/gdpuzxs/p/7222309.html

【项目结构】

springboot + redis缓存使用

【pom.xml配置】

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>lzf.test</groupId>
<artifactId>demo.rediscache</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>demo.rediscache</name>
<description>Demo project for Spring Boot</description>

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>1.5.9.RELEASE</version>
  <relativePath/> 
</parent>

<dependencies>

  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-cache</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
   <exclusions>
    <exclusion>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-logging</artifactId>
    </exclusion>
   </exclusions>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-log4j2</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
  </dependency>
</dependencies>

<build>
  <plugins>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
   </plugin>
  </plugins>
</build>

</project>

【application.properties配置】

spring.cache.type = redis
spring.cache.cache-names=cache1
#spring.cache.redis.
spring.redis.database=0
# Redis服务器地址
spring.redis.host=192.168.6.88
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis..pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0
spring.cache.redis.time-to-live=600000

## LOG4J配置
log4j.rootCategory=DEBUG,stdout
## 控制台输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n

【相关java文件】

　　【Application.java】

package lzf.test.demo.rediscache;

import java.util.Collection;
import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.Cache;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import lzf.test.demo.rediscache.entity.User;
import lzf.test.demo.rediscache.service.OperateUser;

@SpringBootApplication
@RestController
@EnableScheduling
@EnableCaching
public class Application {

public static void main(String[] args) {
  SpringApplication.run(Application.class, args);
}

@Autowired
private RedisCacheManager redisCacheManager;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private OperateUser operateUser;
@Autowired
private RedisTemplate redisTemplate;

@RequestMapping("/age/{age}")
public String testRedis(@PathVariable String age){
  ValueOperations<String, String> ops =stringRedisTemplate.opsForValue();

  ops.set("bbb", age);
  RedisConnection connection = stringRedisTemplate.getConnectionFactory().getConnection();
  List<String> config = connection.getConfig("hostname");
  //--------------------------

  Collection<String> cacheNames = redisCacheManager.getCacheNames();
  Cache cache = null;
  for(String s : cacheNames){
   cache = redisCacheManager.getCache(s);

  }
  return age;

}
/**
* TODO 查询缓存
* @author 刘宗峰
* @param username
* @return
*/
@RequestMapping("/user/{username}")
@ResponseBody
public List<User> findUsers(@PathVariable String username){
  ValueOperations opsForValue = redisTemplate.opsForValue();
  Set keys = redisTemplate.keys("*wang5*".getBytes());
  for(Object key : keys){
   System.out.println(key.toString());
  }
  List<User> us = operateUser.findUser(username);
  return us;

}
/**
* TODO 删除时清理缓存
* @author 刘宗峰
* @param username
* @return
*/
@RequestMapping("/del/{username}")
public String delUser(@PathVariable String username){

  operateUser.delUser(username);
  return "success";
}

@RequestMapping("/update/{username}/{age}")
public String updateUser(@PathVariable String username,@PathVariable Integer age){
  operateUser.updateUser(username, age);
  ValueOperations opsForValue = redisTemplate.opsForValue();
  Set keys = opsForValue.getOperations().keys("*wang5*");
  for(Object key : keys){
   System.out.println(key.toString());
  }
  System.out.println(opsForValue.get(username));
  return "success";
}
}

　　　【OperateUser.java】

package lzf.test.demo.rediscache.service;

import java.util.ArrayList;
import java.util.List;

import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Service;

import lzf.test.demo.rediscache.entity.User;
@Service
@CacheConfig(cacheNames = "cache1")
public class OperateUser {

//1.查询user @Cacheable将查询结果缓存到redis中，（key="#p0"）指定传入的第一个参数作为redis的key
@Cacheable(key ="#p0")
public List<User> findUser(@Param("username") String username){

  List<User> us = new ArrayList<User>();
  User u1 = new User("wang5",12);
  //User u2 = new User("zhao6",15);

  us.add(u1);
  //us.add(u2);

  return us;
}
//如果指定为 true，则方法调用后将立即清空所有缓存
@CacheEvict(key ="#p0",allEntries=true)
public void delUser(@Param("username") String username){
  //
}
@CachePut(key = "#p0")
public List<User> updateUser(@Param("username") String username,Integer age){
  List<User> us = new ArrayList<User>();
  User u1 = new User(username,age);
  us.add(u1);
  return us;
}
}

---------------------------------------------------------------------------

缓存使用的没问题。但是想要手动操作数据，但是没能取出key--value

秒客网

springboot + redis缓存使用

相关文章