开始准备
开始之前我们需要有Redis安装，我们采用本机Docker运行Redis, 主要命令如下
docker pull redis docker run --name my_redis -d -p 6379:6379 redis docker exec -it my_redis bash redis-cli
前面两个命令是启动redis docker, 后两个是连接到docker, 在使用redis-cli 去查看redis里面的内容，主要查看我们存在redis里面的数据。
RedisTemplate
我们先从RedisTemplate开始，这个是最好理解的一种方式，我之前在工作中也使用过这种方式，先看代码示例 我们先定义一个POJO类
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Book implements Serializable {
private Long id;
private String name;
private String author;
}
一个很简单的BOOK类，三个字段： id,name和author. 再来一个RedisTemplate的Bean
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
再定义一个使用这个RedisTemplate的Service类
public Optional findOneBook(String name) {
HashOperations hashOperations = redisTemplate.opsForHash();
if (redisTemplate.hasKey(CACHE) && hashOperations.hasKey(CACHE, name)) {
log.info("Get book {} from Redis.", name);
return Optional.of(hashOperations.get(CACHE, name));
}
Optional book = bookRepository.getBook(name);
log.info("Book Found: {}", book);
if (book.isPresent()) {
log.info("Put book {} to Redis.", name);
hashOperations.put(CACHE, name, book.get());
redisTemplate.expire(CACHE, 10, TimeUnit.MINUTES);
}
return book;
}
我们使用Hash来存储这个Book信息，在上面的方法中查找书名存不存在Redis中，如果存在就直接返回，如果不存在就去持久化存储中找，找到就再通过Template写入到Redis中， 这是缓存的通用做法。 使用起来感觉很方便。 我们这里为了简单没有使用持久化存储，就硬编码了几条数据, 代码如下
@Repository
public class BookRepository {
Map bookMap = new HashMap();
public BookRepository(){
bookMap.put("apache kafka", Book.builder()
.name("apache kafka").id(1L).author("zhangsan")
.build());
bookMap.put("python", Book.builder()
.name("python").id(2L).author("lisi")
.build());
}
public Optional getBook(String name){
if(bookMap.containsKey(name)){
return Optional.of(bookMap.get(name));
}
else{
return Optional.empty();
}
}
}
我们调用 bookService.findOneBook(“python”)和bookService.findOneBook(“apache kafka”); 来把数据写入到换存中
我们来看下存储在Redis的数据长什么样子。
127.0.0.1:6379> keys * 1) "xacxedx00x05tx00x04book" 127.0.0.1:6379> type "xacxedx00x05tx00x04book" hash 127.0.0.1:6379> hgetall "xacxedx00x05tx00x04book" 1) "xacxedx00x05tx00x06python" 2) "xacxedx00x05srx00&com.ken.redistemplatesample.model.Book=x19x96xfbx7fx7fxdaxbex02x00x03Lx00x06authortx00x12Ljava/lang/String;Lx00x02idtx00x10Ljava/lang/Long;Lx00x04nameqx00~x00x01xptx00x04lisisrx00x0ejava.lang.Long;x8bxe4x90xccx8f#xdfx02x00x01Jx00x05valuexrx00x10java.lang.Numberx86xacx95x1dx0bx94xe0x8bx02x00x00xpx00x00x00x00x00x00x00x02tx00x06python" 3) "xacxedx00x05tx00x0capache kafka" 4) "xacxedx00x05srx00&com.ken.redistemplatesample.model.Book=x19x96xfbx7fx7fxdaxbex02x00x03Lx00x06authortx00x12Ljava/lang/String;Lx00x02idtx00x10Ljava/lang/Long;Lx00x04nameqx00~x00x01xptx00bzhangsansrx00x0ejava.lang.Long;x8bxe4x90xccx8f#xdfx02x00x01Jx00x05valuexrx00x10java.lang.Numberx86xacx95x1dx0bx94xe0x8bx02x00x00xpx00x00x00x00x00x00x00x01tx00x0capache kafka"
我们可以看到数据被存在了key是“xacxedx00x05tx00x04book”的一个Hash表中， Hash里面有两条记录。 大家发现一个问题没有？ 就是这个key不是我们想象的用“book”做key,而是多了一串16进制的码， 这是因为RedisTemplate使用了默认的JdkSerializationRedisSerializer 去序列化我们的key和value, 如果大家都用Java语言那没有问题， 如果有人用Java语言写，有人用别的语言读，那就有问题，就像我开始的时候用hgetall “book”始终拿不到数据那样。 RedisTemplate也提供了StringRedisTemplate来方便大家需要使用String来序列化redis里面的数据。简单看下代码
@Bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
{
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
public Optional getBookString(String name){
HashOperations hashOperations = stringRedisTemplate.opsForHash();
if (stringRedisTemplate.hasKey(STRINGCACHE) && hashOperations.hasKey(STRINGCACHE, name)) {
log.info("Get book {} from Redis.", name);
return Optional.of(hashOperations.get(STRINGCACHE, name));
}
Optional book = bookRepository.getBook(name);
log.info("Book Found: {}", book);
if (book.isPresent()) {
log.info("Put book {} to Redis.", name);
hashOperations.put(STRINGCACHE, name, book.get().getAuthor());
stringRedisTemplate.expire(STRINGCACHE, 10, TimeUnit.MINUTES);
return Optional.of(book.get().getAuthor());
}
return Optional.empty();
}
使用上就没有那么方便，你就得自己写需要存的是哪个字段，读出来是哪个字段。
127.0.0.1:6379> keys * 1) "string_book" 127.0.0.1:6379> hgetall string_book 1) "python" 2) "lisi" 3) "apache kafka" 4) "zhangsan"
如上图所示，使用客户端读出来看起来就比较清爽一些。也可以看到占用的Size会小很多，我们这个例子相差7倍，如果是数据量大，这个还是比较大的浪费。
127.0.0.1:6379> keys * 1) "xacxedx00x05tx00x04book" 2) "string_book" 127.0.0.1:6379> memory usage "string_book" (integer) 104 127.0.0.1:6379> memory usage "xacxedx00x05tx00x04book" (integer) 712
JPA Repository
我们知道使用JPA Repository来访问DataBase的时候，增删改查那样的操作能够很方便的实现，基本就是定义个接口，代码都不用写，Spring就帮我们完成了大部分的工作，那么访问Redis是不是也可以这样呢？ 答案是肯定的，我们来看代码 首先我们还是定义一个POJO
@RedisHash(value = "cache-book", timeToLive = 600)
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CacheBook implements Serializable {
@Id
private Long userId;
@Indexed
private String name;
private String author;
}
这个类与我们上面template上面的类的区别就是我们加了两个注解， 在类开头加了 @RedisHash(value = “cache-book”, timeToLive = 600) 在字段上面加了@Id和@Indexed 定义一个Repository的接口
public interface CacheBookRepository extends CrudRepository {
Optional findOneByName(String name);
}
再定义一个service和上面那个例子template一样，缓存中有就到缓存中拿，没有就到持久化存储中找，并写入缓存
@Slf4j
@Service
public class BookService {
private static final String CACHE = "repository-book";
@Autowired
private CacheBookRepository cacheRepository;
@Autowired
private BookRepository bookRepository;
public Optional findOneBook(String name) {
Optional optionalCacheBook = cacheRepository.findOneByName(name);
if(!optionalCacheBook.isPresent())
{
Optional book = bookRepository.getBook(name);
log.info("Book Found: {}", book);
if (book.isPresent()) {
log.info("Put book {} to Redis.", name);
cacheRepository.save(book.get());
}
return book;
}
return optionalCacheBook;
}
}
代码很简单，简单到不敢相信是真的。 还是一样，调用这个方法，我们来看存在Redis里面的数据
127.0.0.1:6379> keys * 1) "repository-book:2" 2) "repository-book:2:idx" 3) "repository-book" 4) "repository-book:name:apache kafka" 5) "repository-book:name:python" 6) "repository-book:1:idx" 7) "repository-book:1"
哇，感觉存的内容有些多， 不用怕我们来看下各自存什么数据 首先看最短的一个
127.0.0.1:6379> smembers repository-book 1) "1" 2) "2"
它里面存的是我们的id所有的value, 可以用来判断id是否存在 再来看
127.0.0.1:6379> hgetall repository-book:2 1) "_class" 2) "com.ken.redisrepositorysample.model.CacheBook" 3) "author" 4) "lisi" 5) "name" 6) "python" 7) "userId" 8) "2"
这个是我们数据存放的地方
127.0.0.1:6379> smembers repository-book:1:idx 1) "repository-book:name:apache kafka" 127.0.0.1:6379> smembers "repository-book:name:apache kafka" 1) "1"
另外两个都是set， 存在在它们里面的数据是索引信息。 由此可以看出通过JPA Repository 的方式，代码很少，而且存储的数据也很通用，个人觉得是比较理想的访问方法。
Cache
我们已经看了两种方式，在访问的时候遵循这样的模式：缓存中有就从缓存中返回，没有就从持久化存储中找，然后写入缓存，这部分代码我也不想自己写，那么Cache就是你的救星。 我们先看代码 我们这次使用内存数据库H2作为持久化存储， 放一个schema.sql在resouces下面
drop table t_book if exists;
create table t_book (
id bigint auto_increment,
create_time timestamp,
update_time timestamp,
name varchar(255),
author varchar(200),
primary key (id)
);
insert into t_book (name, author, create_time, update_time) values ('python', 'zhangsan', now(), now());
insert into t_book (name, author, create_time, update_time) values ('hadoop', 'lisi', now(), now());
insert into t_book (name, author, create_time, update_time) values ('java', 'wangwu', now(), now());
然后定义POJO
@Entity
@Table(name = "T_BOOK")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CacheBook implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String author;
@Column(updatable = false)
@CreationTimestamp
private Date createTime;
@UpdateTimestamp
private Date updateTime;
}
完全是和数据库绑定的代码，和缓存没有任何关系 一个Repository来访问数据库
public interface BookRepository extends JpaRepository {
}
定义一个service来调用它
@Slf4j
@Service
@CacheConfig(cacheNames = "cache-book")
public class BookService {
@Autowired
private BookRepository bookRepository;
@Cacheable
public List findAllCoffee() {
return bookRepository.findAll();
}
@CacheEvict
public void reloadCoffee() {
}
}
这里就比较关键了，在类上加上了注解 @CacheConfig(cacheNames = “cache-book”) 在方法上面加上了Cacheable和CacheEvict， Cacheable这个方法就是用来实现逻辑，有就从缓存中拿，没有就从数据库拿的，CacheEvict是调用这个方法的时候清除缓存。 然后再启动入口程序的地方加上注解 @EnableJpaRepositories @EnableCaching(proxyTargetClass = true) 在配置文件application.properties中加上
spring.jpa.hibernate.ddl-auto=none spring.jpa.properties.hibernate.show_sql=true spring.jpa.properties.hibernate.format_sql=true management.endpoints.web.exposure.include=* spring.cache.type=redis spring.cache.cache-names=cache-book spring.cache.redis.time-to-live=600000 spring.cache.redis.cache-null-values=false spring.redis.host=localhost
这样就可以了， 感觉就是通过配置下就把缓存给完成了，非常的简单 我们来看Redis中是怎么存的
127.0.0.1:6379> keys * 1) "cache-book::SimpleKey []" 127.0.0.1:6379> get "cache-book::SimpleKey []" "xacxedx00x05srx00x13java.util.ArrayListxx81xd2x1dx99xc7ax9dx03x00x01Ix00x04sizexpx00x00x00x03wx04x00x00x00x03srx00(com.ken.rediscachesample.model.CacheBookxecxcbR=xe1Ux9bxf7x02x00x05Lx00x06authortx00x12Ljava/lang/String;Lx00ncreateTimetx00x10Ljava/util/Date;Lx00x02idtx00x10Ljava/lang/Long;Lx00x04nameqx00~x00x03Lx00nupdateTimeqx00~x00x04xptx00bzhangsansrx00x12java.sql.Timestamp&x18xd5xc8x01Sxbfex02x00x01Ix00x05nanosxrx00x0ejava.util.Datehjx81x01KYtx19x03x00x00xpwbx00x00x01x84xff]x85xb0xb-x81x80srx00x0ejava.lang.Long;x8bxe4x90xccx8f#xdfx02x00x01Jx00x05valuexrx00x10java.lang.Numberx86xacx95x1dx0bx94xe0x8bx02x00x00xpx00x00x00x00x00x00x00x01tx00x06pythonsqx00~x00bwbx00x00x01x84xff]x85xb0xb-x81x80sqx00~x00x02tx00x04lisisqx00~x00bwbx00x00x01x84xff]x85xb0xb
看到没有，就是当成Redis里面的String来存的， 如果数据量比较小，那是非常的方便，如果数据量大，这种方式就有些问题了。
总结
我们看了这三种方式，这里仅仅是做了个入门，每个里面都有很多细节的地方需要去研究和使用，整体的感觉是要想使用的简单，那么存储在Redis中的数据就要量少，量大后，就需要自己来定制了，那基本上要用RedisTemplate来做一些工作。
以上就是RedisTemplate访问Redis的更好方法的详细内容，更多关于RedisTemplate访问Redis的资料请关注IT俱乐部其它相关文章！
