07-Redis在SpringBoot工程中的综合应用

云惠网小编 2021年10月14日13:18:59
评论
7696字阅读25分39秒
摘要

业务描述从一个博客数据库中查询所有的文章标签,然后存储到缓存(Cache),后续查询时可从缓存获取。提高其查询性能。准备工作初始化数据库数据初始化数据库中数据,SQL脚本如下:DROP DATABASE IF EXISTS `blog`;CREATE DATABASE `blog` DEFAULT character set utf8mb4;SET names utf8mb4;SET FOREIGN_KEY_CHECKS = 0;USE `blog`;CREATE TABLE `tb_

广告也精彩

创建Tag信息的数据访问接口,代码如下:

我们还可以定义Redis中key和value的序列化方式,例如:

@EnableCaching //启动AOP方式的缓存配置
@SpringBootApplication
public class RedisApplication {
....
}

创建一个Tag类,基于此类型的对象存储Tag(标签信息),代码如下:

业务逻辑代码设计及实现

package com.jt.blog.controller;
import com.jt.blog.domain.Tag;
import com.jt.blog.service.TagService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
@RestController
@RequestMapping("/tag")
public class TagController {
@Autowired
private TagService tagService;
@GetMapping
public  List<Tag> doSelectTags(){
return  tagService.selectTags());//1.redis,2.mysql
}
}

启动服务,打开浏览器进行访问测试。同时思考,我们是否可以在这个层加一个本地cache。

在项目的配置文件(例如application.yml)中添加数据库访问配置,例如:

package com.jt.blog.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
/**
* 标签类的设计
*/
@TableName("tb_tag")
public class Tag implements Serializable {
private static final long serialVersionUID = 4504013456197711455L;
/**标签id*/
@TableId(type = IdType.AUTO)
private Long id;
/**标签名*/
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Tag{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
package com.jt.blog.controller;
import com.jt.blog.domain.Tag;
import com.jt.blog.service.TagService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
@RestController
@RequestMapping("/tag")
public class TagController {
@Autowired
private TagService tagService;
//此对象存哪了?(JVM)
private List<Tag> tags=new CopyOnWriteArrayList<>();//本地 cache
@GetMapping
public  List<Tag> doSelectTags(){
if(tags.isEmpty()) {
synchronized (tags) {
if(tags.isEmpty()) {
tags.addAll(tagService.selectTags());//1.redis,2.mysql
}
}
}
return tags;
}
}

添加数据库访问配置

从一个博客数据库中查询所有的文章标签,然后存储到缓存(Cache),后续查询时可从缓存获取。提高其查询性能。

第二步:定义TagServiceImpl类,代码如下:

第三步:定义TagServiceTests单元测试类并进行单元测试,代码如下:

Service 逻辑对象设计

package com.jt.blog.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.blog.domain.Tag;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface TagMapper
extends BaseMapper<Tag> {
}

设计TagService接口及实现类,定义Tag(标签)业务逻辑。
第一步:定义TagService接口,代码如下:

本章节重点是学习项目中缓存(Cache)的一种应用思想。

spring:
datasource:
url: jdbc:mysql:///blog?serverTimezone=Asia/Shanghai&characterEncoding=utf8
username: root
password: root

初始化数据库中数据,SQL脚本如下:

创建Tag控制逻辑对象,用于处理请求和响应逻辑,代码如下:

业务逻辑代码优化

Dao 逻辑对象设计

Controller逻辑对象设计

package com.jt.blog.dao;
import com.jt.blog.domain.Tag;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
public class TagMapperTests {
@Autowired
private TagMapper tagMapper;
@Test
void testSelectList(){
List<Tag> tags =
tagMapper.selectList(null);
for(Tag t:tags){
System.out.println(t);
//System.out.println(t.getId()+"/"+t.getName());
}
}
}

业务描述

@Cacheable(value = "tagCache")
@Override
public List<Tag> selectTags() {
return tagMapper.selectList(null);
}
package com.jt.blog.service;
import com.jt.blog.domain.Tag;
import java.util.List;
public interface TagService {
/**
* 查询所有的标签
* @return
*/
List<Tag> selectTags();
}

说明,假如将List存储到redis,此时Tag必须实现Serializable接口。

准备工作

创建单元测试类,TagMapper中的相关方法进行单元测试,例如:

在Controller中添加一个本地缓存,减少对远程redis缓存的访问,例如:

DROP DATABASE IF EXISTS `blog`;
CREATE DATABASE `blog` DEFAULT character set utf8mb4;
SET names utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
USE `blog`;
CREATE TABLE `tb_tag` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`name` varchar(255) NOT NULL COMMENT 'data_id',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='tb_tag';
insert into `tb_tag` values (null,"mysql"),(null,"redis");

目标:简化缓存代码的编写
解决方案:基于AOP(面向切面编程)方式实现缓存应用
实践步骤:
第一步:[email protected](开启AOP方式的缓存配置),例如:

package com.jt.blog.service.impl;
import com.jt.blog.dao.TagMapper;
import com.jt.blog.domain.Tag;
import com.jt.blog.service.TagService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class TagServiceImpl implements TagService {
//RedisAutoConfiguration 类中做的RedisTemplate的配置
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private TagMapper tagMapper;
@Override
public List<Tag> selectTags() {
//1.从redis查询Tag信息,redis有则直接返回
ValueOperations<String,List<Tag>> valueOperations =
redisTemplate.opsForValue();
List<Tag> tags=valueOperations.get("tags");
if(tags!=null&&!tags.isEmpty())return tags;
//2.从redis没有获取tag信息,查询mysql
tags = tagMapper.selectList(null);
//3.将从mysql查询到tag信息存储到redis
valueOperations.set("tags", tags);
//4.返回查询结果
return tags;
}
}

Domain对象设计

Controller中添加本地缓存

第二步:重构TagServiceImpl中的selectTags()方法,[email protected],例如:

<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--mybatis-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.2</version>
</dependency>

其中,写好这个配置类后,可以进行单元测试,检测redis中数据的存储.

总结(Summary)

添加项目依赖

初始化数据

其中,@Cacheable描述的方法为AOP中的一个切入点方法,访问这个方法时,系统底层会通过一个拦截器,检查缓存中是否有你要的数据,假如有则直接返回,没有则执行方法从数据库查询数据.

文章目录

  • 业务描述
  • 准备工作
    • 初始化数据
    • 添加项目依赖
    • 添加数据库访问配置
  • 业务逻辑代码设计及实现
    • Domain对象设计
    • Dao 逻辑对象设计
    • Service 逻辑对象设计
    • Controller逻辑对象设计
  • 业务逻辑代码优化
    • Service中缓存应用优化
    • Controller中添加本地缓存
  • 总结(Summary)
package com.jt.blog;
import org.springframework.cache.annotation.CachingConfigurerSupport;
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.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.*;
import java.time.Duration;
@Configuration
public class RedisCacheConfig extends CachingConfigurerSupport {
@Bean
public KeyGenerator keyGenerator() {
return (o, method, params) -> {
StringBuilder sb = new StringBuilder();
sb.append(o.getClass().getName()); // 类目
sb.append("::");
sb.append(method.getName()); // 方法名
for (Object param : params) {
sb.append(param.toString());
}
return sb.toString();
};
}
// 配置缓存管理器
@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(60)) // 60s缓存失效
// 设置key的序列化方式
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
// 设置value的序列化方式
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
new Jackson2JsonRedisSerializer<Object>(Object.class)))
// 不缓存null值
.disableCachingNullValues();
return RedisCacheManager.builder(connectionFactory)
.cacheDefaults(config)
.transactionAware()
.build();
}
}

在jt-template工程的原有依赖基础上添加mysql数据库访问依赖,例如:

package com.jt.blog.service;
import com.jt.blog.domain.Tag;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
public class TagServiceTests {
@Autowired
private TagService tagService;
@Test
void testSelectTags(){
List<Tag> tags=
tagService.selectTags();
System.out.println(tags);
}
}

Service中缓存应用优化

本文转自 https://blog.csdn.net/maitian_2008/article/details/120743729

腾讯云618
云惠网小编
[java篇]一口气搞定异常处理 java

[java篇]一口气搞定异常处理

前言:博主在以前的博客中曾经也提起了异常,比如[java篇]多态,接口中在实现clone接口时,就用到了抛出异常,今天就给大家详细的介绍一下关于异常的一些知识。前期文章:1.[ja...
腾讯云618

发表评论