使用Java实现先查询缓存再查询数据库

作者:??summo??? 时间:2024-01-14 02:18:05 

前言

在访问量大的时候,为了提高查询效率,我们会将数据先缓存到redis中。先查询redis,查询不到再去查询数据库,实现这个逻辑也不复杂,写一个if(...)else{...}也就行了。这种做法也不是不行,就是看起来有点儿粗糙,所以我想换一种更优雅的写法。

栗子

现有一个使用商品名称查询商品的需求,要求先查询缓存,查不到则去数据库查询;从数据库查询到之后加入缓存,再查询时继续先查询缓存。

思路分析

可以写一个条件判断,伪代码如下:

//先从缓存中查询
String goodsInfoStr = redis.get(goodsName);
if(StringUtils.isBlank(goodsInfoStr)){
//如果缓存中查询为空,则去数据库中查询
Goods goods = goodsMapper.queryByName(goodsName);
//将查询到的数据存入缓存
goodsName.set(goodsName,JSONObject.toJSONString(goods));
//返回商品数据
return goods;
}else{
//将查询到的str转换为对象并返回
return JSON.parseObject(goodsInfoStr, Goods.class);
}

上面这串代码也可以实现查询效果,看起来也不是很复杂,但是这串代码是不可复用的,只能用在这个场景。假设在我们的系统中还有很多类似上面商品查询的需求,那么我们需要到处写这样的if(...)else{...}。作为一个程序员,不能把类似的或者重复的代码统一起来是一件很难受的事情,所以需要对这种场景的代码进行优化。

上面这串代码的问题在于:入参不固定、返回值也不固定,如果仅仅是参数不固定,使用泛型即可。但最关键的是查询方法也是不固定的,比如查询商品和查询用户肯定不是一个查询方法吧。

所以如果我们可以把一个方法(即上面的各种查询方法)也能当做一个参数传入一个统一的判断方法就好了,类似于:

/**
* 这个方法的作用是:先执行method1方法,如果method1查询或执行不成功,再执行method2方法
*/
public static<T> T selectCacheByTemplate(method1,method2)

想要实现上面的这种效果,就不得不提到Java8的新特性:函数式编程

原理介绍

在Java中有一个package:java.util.function ,里面全部是接口,并且都被@FunctionalInterface注解所修饰。

Function分类

  • Consumer(消费):接受参数,无返回值

  • Function(函数):接受参数,有返回值

  • Operator(操作):接受参数,返回与参数同类型的值

  • Predicate(断言):接受参数,返回boolean类型

  • Supplier(供应):无参数,有返回值

具体我就不在赘述了,可以参考:Java 函数式编程梳理

代码实现

那么接下来就来使用Java优雅的实现先查询缓存再查询数据库吧!

项目代码

配置文件

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.7.2</version>
       <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.example</groupId>
   <artifactId>SpringBoot-query</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>SpringBoot-query</name>
   <description>Demo project for Spring Boot</description>
   <properties>
       <java.version>1.8</java.version>
   </properties>
   <dependencies>
       <!-- redis -->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-data-redis</artifactId>
       </dependency>
       <!-- fastjson -->
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>fastjson</artifactId>
           <version>1.2.83</version>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</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>

项目结构

使用Java实现先查询缓存再查询数据库

 其中CacheService是从缓存中查询数据,GoodsService是从数据库中查询数据

SpringBootQueryApplication.java

package com.example.springbootquery;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringBootQueryApplication {

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

}

Goods.java

package com.example.springbootquery.entity;
public class Goods {
   private String goodsName;
   private Integer goodsTotal;
   private Double price;
   public String getGoodsName() {
       return goodsName;
   }
   public void setGoodsName(String goodsName) {
       this.goodsName = goodsName;
   }
   public Integer getGoodsTotal() {
       return goodsTotal;
   }
   public void setGoodsTotal(Integer goodsTotal) {
       this.goodsTotal = goodsTotal;
   }
   public Double getPrice() {
       return price;
   }
   public void setPrice(Double price) {
       this.price = price;
   }
   @Override
   public String toString() {
       return "Goods{" +
               "goodsName='" + goodsName + '\'' +
               ", goodsTotal='" + goodsTotal + '\'' +
               ", price=" + price +
               '}';
   }
}

CacheSelector.java

自定义函数式接口:

package com.example.springbootquery.function;

@FunctionalInterface
public interface CacheSelector<T> {
   T select() throws Exception;
}

CacheService.java

package com.example.springbootquery.service;

import com.example.springbootquery.entity.Goods;
public interface CacheService {
   /**
    * 从缓存中获取商品
    *
    * @param goodsName 商品名称
    * @return goods
    */
   Goods getGoodsByName(String goodsName) throws Exception;
}

CacheServiceImpl.java

package com.example.springbootquery.service.impl;

import com.alibaba.fastjson.JSON;
import com.example.springbootquery.entity.Goods;
import com.example.springbootquery.service.CacheService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

@Service("cacheService")
public class CacheServiceImpl implements CacheService {

@Autowired
   private StringRedisTemplate redisTemplate;

@Override
   public Goods getGoodsByName(String goodsName) throws Exception {
       String s = redisTemplate.opsForValue().get(goodsName);
       return null == s ? null : JSON.parseObject(s, Goods.class);
   }
}

GoodsService.java

package com.example.springbootquery.service;
import com.example.springbootquery.entity.Goods;
public interface GoodsService {
   Goods getGoodsByName(String goodsName);
}

GoodsServiceImpl.java

这里我就不连接数据库了,模拟一个返回

package com.example.springbootquery.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.example.springbootquery.entity.Goods;
import com.example.springbootquery.service.GoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class GoodsServiceImpl implements GoodsService {
   @Autowired
   private StringRedisTemplate stringRedisTemplate;
   @Override
   public Goods getGoodsByName(String goodsName) {
       Goods goods = new Goods();
       goods.setGoodsName("商品名1");
       goods.setGoodsTotal(20);
       goods.setPrice(30.0D);
       stringRedisTemplate.opsForValue().set(goodsName, JSONObject.toJSONString(goods));
       return goods;
   }
}

BaseUtil.java (核心类)

因为我不关心参数,只需要一个返回值就行了,所以这里使用的是Supplier。

package com.example.springbootquery.util;
import com.example.springbootquery.function.CacheSelector;
import java.util.function.Supplier;
public class BaseUtil {
   /**
    * 缓存查询模板
    *
    * @param cacheSelector    查询缓存的方法
    * @param databaseSelector 数据库查询方法
    * @return T
    */
   public static <T> T selectCacheByTemplate(CacheSelector<T> cacheSelector, Supplier<T> databaseSelector) {
       try {
           System.out.println("query data from redis ······");
           // 先查 Redis缓存
           T t = cacheSelector.select();
           if (t == null) {
               // 没有记录再查询数据库
               System.err.println("redis 中没有查询到");
               System.out.println("query data from database ······");
               return databaseSelector.get();
           } else {
               return t;
           }
       } catch (Exception e) {
           // 缓存查询出错,则去数据库查询
           e.printStackTrace();
           System.err.println("redis 查询出错");
           System.out.println("query data from database ······");
           return databaseSelector.get();
       }
   }
}

用法

package com.example.springbootquery;

import com.example.springbootquery.entity.Goods;
import com.example.springbootquery.service.CacheService;
import com.example.springbootquery.service.GoodsService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static com.example.springbootquery.util.BaseUtil.selectCacheByTemplate;
@SpringBootTest
class SpringBootQueryApplicationTests {
   @Autowired
   private CacheService cacheService;
   @Autowired
   private GoodsService userService;
   @Test
   void contextLoads() throws Exception {
       Goods user = selectCacheByTemplate(
               () -> cacheService.getGoodsByName("商品名1"),
               () -> userService.getGoodsByName("商品名1")
       );
       System.out.println(user);
   }
}

第一次从数据中查询

使用Java实现先查询缓存再查询数据库

第二次从缓存中查询

使用Java实现先查询缓存再查询数据库

来源:https://juejin.cn/post/7124885941117779998

标签:Java,查询,缓存,数据库
0
投稿

猜你喜欢

  • Python基于回溯法子集树模板解决取物搭配问题实例

    2023-11-20 04:46:53
  • 微信小程序简单的canvas裁剪图片功能详解

    2023-08-24 07:49:20
  • Python自动化测试笔试面试题精选

    2021-05-17 03:32:59
  • ASP连接MSSQL2005 数据库

    2009-03-08 19:20:00
  • Python学习笔记之Break和Continue用法分析

    2023-02-12 04:55:32
  • Python安装第三方库的3种方法

    2022-02-03 03:10:47
  • SQL Server 2005 内置工具建审查系统

    2009-01-19 14:24:00
  • PHP中大于2038年时间戳的问题处理方案

    2023-07-03 14:33:26
  • vueJs函数toRaw markRaw使用对比详解

    2024-04-09 10:46:23
  • Python爬虫自动化爬取b站实时弹幕实例方法

    2023-03-21 04:45:42
  • 基于java线程池读取单个SQL数据库表

    2024-01-25 08:17:00
  • Vue常用传值方式、父传子、子传父及非父子实例分析

    2024-05-29 22:43:32
  • pycharm中连接mysql数据库的步骤详解

    2024-01-19 22:22:40
  • numpy增加维度、删除维度的方法

    2023-12-07 22:29:01
  • php字符串过滤strip_tags()函数用法实例分析

    2023-09-04 14:05:00
  • python将.ppm格式图片转换成.jpg格式文件的方法

    2023-02-16 19:19:54
  • 简单form标准化实例——整体布局

    2007-05-11 17:04:00
  • python神经网络MobileNet模型的复现详解

    2022-09-24 19:54:14
  • Pytorch 如何加速Dataloader提升数据读取速度

    2023-11-12 00:00:32
  • 图文详解在Anaconda安装Pytorch的详细步骤

    2022-12-27 10:37:25
  • asp之家 网络编程 m.aspxhome.com