首页 > 其他分享 >面试官:如何实现多级缓存?

面试官:如何实现多级缓存?

时间:2024-02-20 16:12:14浏览次数:24  
标签:面试官 缓存 cache springframework 多级 import org public

对于高并发系统来说,有三个重要的机制来保障其高效运行,它们分别是:缓存、限流和熔断。而缓存是排在最前面也是高并发系统之所以高效运行的关键手段,那么问题来了:缓存只使用 Redis 就够了吗?

1.冗余设计理念

当然不是,不要把所有鸡蛋放到一个篮子里,成熟的系统在关键功能实现时一定会考虑冗余设计,注意这里的冗余设计不是贬义词。

冗余设计是在系统或设备完成任务起关键作用的地方,增加一套以上完成相同功能的功能通道(or 系统)、工作元件或部件,以保证当该部分出现故障时,系统或设备仍能正常工作,以减少系统或者设备的故障概率,提高系统可靠性。

例如,飞机的设计,飞机正常运行只需要两个发动机,但在每台飞机的设计中可能至少会设计四个发动机,这就有冗余设计的典型使用场景,这样设计的目的是为了保证极端情况下,如果有一个或两个发动机出现故障,不会因为某个发动机的故障而引起重大的安全事故。

2.多级缓存概述

缓存功能的设计也是一样,我们在高并发系统中通常会使用多级缓存来保证其高效运行,其中的多级缓存就包含以下这些:

  1. 浏览器缓存:它的实现主要依靠 HTTP 协议中的缓存机制,当浏览器第一次请求一个资源时,服务器会将该资源的相关缓存规则(如 Cache-Control、Expires 等)一同返回给客户端,浏览器会根据这些规则来判断是否需要缓存该资源以及该资源的有效期。
  2. Nginx 缓存:在 Nginx 中配置中开启缓存功能。
  3. 分布式缓存:所有系统调用的中间件都是分布式缓存,如 Redis、MemCached 等。
  4. 本地缓存:JVM 层面,单系统运行期间在内存中产生的缓存,例如 Caffeine、Google Guava 等。

以下是它们的具体使用。

2.1 开启浏览器缓存

在 Java Web应用中,实现浏览器缓存可以使用 HttpServletResponse 对象来设置与缓存相关的响应头,以开启浏览器的缓存功能,它的具体实现分为以下几步。

① 配置 Cache-Control

Cache-Control 是 HTTP/1.1 中用于控制缓存策略的主要方式。它可以设置多个指令,如 max-age(定义资源的最大存活时间,单位秒)、no-cache(要求重新验证)、public(指示可以被任何缓存区缓存)、private(只能被单个用户私有缓存存储)等,设置如下:

response.setHeader("Cache-Control", "max-age=3600, public"); // 缓存一小时

② 配置 Expires

设置一个绝对的过期时间,超过这个时间点后浏览器将不再使用缓存的内容而向服务器请求新的资源,设置如下:

response.setDateHeader("Expires", System.currentTimeMillis() + 3600 * 1000); // 缓存一小时

③ 配置 ETag

ETag(实体标签)一种验证机制,它为每个版本的资源生成一个唯一标识符。当客户端发起请求时,会携带上先前接收到的 ETag,服务器根据 ETag 判断资源是否已更新,若未更新则返回 304 Not Modified 状态码,通知浏览器继续使用本地缓存,设置如下:

String etag = generateETagForContent(); // 根据内容生成ETag
response.setHeader("ETag", etag);

④ 配置 Last-Modified

指定资源最后修改的时间戳,浏览器下次请求时会带上 If-Modified-Since 头,服务器对比时间戳决定是否返回新内容或发送 304 状态码,设置如下:

long lastModifiedDate = getLastModifiedDate();
response.setDateHeader("Last-Modified", lastModifiedDate);

整体配置

在 Spring Web 框架中,可以通过 HttpServletResponse 对象来设置这些头信息。例如,在过滤器中设置响应头以启用缓存:

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
       throws IOException, ServletException {
   HttpServletResponse httpResponse = (HttpServletResponse) response;
   // 设置缓存策略
   httpResponse.setHeader("Cache-Control", "max-age=3600");

   // 其他响应头设置...
   chain.doFilter(request, response);
}

以上就是在 Java Web 应用程序中利用 HTTP 协议特性控制浏览器缓存的基本方法。

2.2 开启 Nginx 缓存

Nginx 中开启缓存的配置总共有以下 5 步。

① 定义缓存配置

在 Nginx 配置中定义一个缓存路径和配置,通过 proxy_cache_path 指令完成,例如,以下配置:

proxy_cache_path /path/to/cache levels=1:2 keys_zone=my_cache:10m max_size=10g inactive=60m use_temp_path=off;

其中:

  • /path/to/cache:这是缓存文件的存放路径。
  • levels=1:2:定义缓存目录的层级结构。
  • keys_zone=my_cache:10m:定义一个名为 my_cache 的共享内存区域,大小为 10MB。
  • max_size=10g:设置缓存的最大大小为 10GB。
  • inactive=60m:如果在 60 分钟内没有被访问,缓存将被清理。
  • use_temp_path=off:避免在文件系统中进行不必要的数据拷贝。

② 启用缓存

在 server 或 location 块中,使用 proxy_cache 指令来启用缓存,并指定要使用的 keys zone,例如,以下配置:

server {  
    ...  
    location / {  
        proxy_cache my_cache;  
        ...  
    }  
}

③ 设置缓存有效期

使用 proxy_cache_valid 指令来设置哪些响应码的缓存时间,例如,以下配置:

location / {  
    proxy_cache my_cache;  
    proxy_cache_valid 200 304 12h;  
    proxy_cache_valid any 1m;  
    ...  
}

④ 配置反向代理

确保你已经配置了反向代理,以便 Nginx 可以将请求转发到后端服务器。例如,以下配置:

location / {  
    proxy_pass http://backend_server;  
    ...  
}

⑤ 重新加载配置

保存并关闭 Nginx 配置文件后,使用 nginx -s reload 命令重新加载配置,使更改生效。

2.3 使用分布式缓存

在 Spring Boot 项目中使用注解的方式来操作分布式缓存 Redis 的实现步骤如下。

① 添加依赖

在你的 pom.xml 文件中添加 Spring Boot 的 Redis 依赖,如下所示:

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

② 配置 Redis 连接信息

在 application.properties 或 application.yml 文件中配置 Redis 的相关信息,如下所示。

# application.properties  
spring.redis.host=localhost  
spring.redis.port=6379

③ 启动缓存

在 Spring Boot 主类或者配置类上添加 @EnableCaching 注解来启用缓存。

import org.springframework.cache.annotation.EnableCaching;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
  
@SpringBootApplication  
@EnableCaching  
public class Application {  
  
    public static void main(String[] args) {  
        SpringApplication.run(Application.class, args);  
    }  
  
}

④ 使用缓存

在服务类或方法上使用 @Cacheable,@CacheEvict,@CachePut 等注解来定义缓存行为。

例如,使用 @Cacheable 注解来缓存方法的返回值:

import org.springframework.cache.annotation.Cacheable;  
import org.springframework.stereotype.Service;  
  
@Service  
public class UserService {  
    @Cacheable("users")  
    public User findUserById(Long id) {  
        // 模拟从数据库中查询用户  
        return new User(id, "Alice");  
    }  
}

也可以使用 @CacheEvict 注解来删除缓存:

import org.springframework.cache.annotation.CacheEvict;  
import org.springframework.stereotype.Service;  
  
@Service  
public class UserService {  
    @CacheEvict(value = "users", key = "#id")  
    public void deleteUser(Long id) {  
        // 模拟从数据库中删除用户  
    }  
}

在这个例子中,deleteUser 方法会删除 "users" 缓存中 key 为 id 的缓存项。

可以使用 @CachePut 注解来更新缓存:

import org.springframework.cache.annotation.CachePut;  
import org.springframework.stereotype.Service;  
  
@Service  
public class UserService {  
  
    @CachePut(value = "users", key = "#user.id")  
    public User updateUser(User user) {  
        // 模拟更新数据库中的用户信息  
        return user;  
    }  
  
}

在这个例子中,updateUser 方法会更新 "users" 缓存中 key 为 user.id 的缓存项,缓存的值是方法的返回值。

2.4 使用本地缓存

以 Caffeine 本地缓存的使用为例,它在 Spring Boot 项目中的使用如下。

① 添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

② 配置 Caffeine 缓存

在 application.properties 或 application.yml 文件中配置 Caffeine 缓存的相关参数。例如:

# application.properties
spring.cache.type=caffeine
spring.cache.caffeine.spec=initialCapacity=100,maximumSize=1000,expireAfterWrite=10s

这里 spring.cache.caffeine.spec 是一个 Caffeine 规范字符串,用于设置初始容量、最大容量和写入后过期时间等缓存策略,其中:

  • initialCapacity:初始容器容量。
  • maximumSize:最大容量。
  • expireAfterWrite:写入缓存后 N 长时间后过期。

③ 自定义 Caffeine 配置类(可选步骤)

如果需要更复杂的配置,可以创建一个 Caffeine CacheManager 的配置类:

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.CacheResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CaffeineCacheConfig extends CachingConfigurerSupport {

    @Bean
    public CacheManager cacheManager() {
        Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(1000)
                .expireAfterWrite(10, TimeUnit.SECONDS) // 10 秒后过期
                .recordStats(); // 记录缓存统计信息

        return new CaffeineCacheManager("default", caffeine::build);
    }

    @Override
    public CacheResolver cacheResolver() {
        // 自定义缓存解析器(如果需要)
        // ...
        return super.cacheResolver();
    }
}

④ 开启缓存

若要利用 Spring Cache 抽象层,以便通过注解的方式更方便地管理缓存,需要在启动类上添加 @EnableCaching 注解,如下所示:

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableCaching
public class Application {

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

⑤ 使用注解进行缓存操作

在业务逻辑类中使用 @Cacheable、@CacheEvict 等注解实现数据的缓存读取和更新,和上面分布式缓存的使用相同,具体示例如下:

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Cacheable(value = "users", key = "#id") // 假设我们有一个名为"users"的缓存区域
    public User getUserById(Long id) {
        // 这里是真实的数据库查询或其他耗时操作
        return userRepository.findById(id).orElse(null);
    }

    @CacheEvict(value = "users", key = "#user.id")
    public void updateUser(User user) {
        userRepository.save(user);
    }
}

课后思考

除了以上的缓存之外,还有哪些缓存可以加速程序的执行效率呢?

本文已收录到我的面试小站 www.javacn.site,其中包含的内容有:Redis、JVM、并发、并发、MySQL、Spring、Spring MVC、Spring Boot、Spring Cloud、MyBatis、设计模式、消息队列等模块。

标签:面试官,缓存,cache,springframework,多级,import,org,public
From: https://www.cnblogs.com/vipstone/p/18023343

相关文章

  • 视频生成领域的发展概述:从多级扩散到LLM
    2023年是语言模型(llm)和图像生成技术激增的一年,但是视频生成受到的关注相对较少。今年刚到2月份,OpenAI就发布了一个惊人的视频生成模型Sora。虽然它的架构没有披露,但是通过总结现有的视频生成领域可能能对Sora的构架有所理解。在这篇文章中,我们将整理视频生成在最近几年是发展......
  • 认识Redis:不只是缓存,还有这些厉害的功能!
    在当今数据驱动的世界中,快速存取信息成为了技术发展的关键。而在众多存储解决方案中,Redis以其独特的魅力和强大的功能,成为了开发者们的宠儿。今天,就让我们一起来认识一下Redis。一、Redis是什么,可以用来干什么?Redis,英文全称是RemoteDictionaryServer(远程字典服务),是一个开源......
  • Java集合篇之set,面试官:请说一说HashSet、LinkedHashSet、TreeSet的区别?
    写在开头Java的集合世界中主要由List,Set,Queue,Map构成,我们在之前的博文中已经学习了List,接下来我们继续学习Set集合。Set特点:存取无序,不可以存放重复的元素,不可以用下标对元素进行操作HashSet作为Set容器的代表子类,HashSet经常被用到,我们通过源码去分析它【源码查看】public......
  • 面试官:如何实现10亿数据判重?
    当数据量比较大时,使用常规的方式来判重就不行了。例如,使用MySQL数据库判重,或使用List.contains()或Set.contains()判重就不可行,因为MySQL在数据量大时查询就会非常慢,而数据库又是及其珍贵的全局数据库资源。《阿里巴巴Java开发手册》上也说了,如果单表数据量超过500万......
  • redis高频问题--缓存--数据淘汰策略
    redis-数据淘汰策略redis具体的有八种淘汰策略数据淘汰策略建议总结问答......
  • redis高频问题--缓存--数据过期策略
    redis的数据过期策略惰性删除定期删除总结回答......
  • redis高频问题--缓存击穿
    缓存击穿互斥锁==分布式锁互斥锁多用于关于钱的业务,保持强一致性性能差一些,因为需要互相等待逻辑过期保证高可用性,注重于用户的体验......
  • Vulkan中的同步与缓存控制
    1.IntroductionVulkan提供显式的同步结构,允许CPU与GPU同步命令的执行。并且还可以控制GPU中命令的执行顺序。所有执行的Vulkan命令都将进入队列,并以某种未定义的顺序“不间断”执行。有时,我们明确希望在执行新操作之前确保某些操作已完成。在编写vulkan应用时,虽然对给......
  • 分布式缓存应用:Memcache 或 Redis
    为什么要使用分布式缓存高并发环境下,例如典型的淘宝双11秒杀,几分钟内上亿的用户涌入淘宝,这个时候如果访问不加拦截,让大量的读写请求涌向数据库,由于磁盘的处理速度与内存显然不在一个量级,服务器马上就要宕机。缓存可以将经常读取的数据存储在快速的内存中,从而避免了频繁访问慢速......
  • 通过注解实现本地缓存caffeine的学习
    注解源码如下1@Target(ElementType.METHOD)2@Retention(RetensionPolicy.RUNTIME)3@Documented4public@interfaceRvcCache{5Strngkey();6Stringid()defaultStringUtils.EMPTY;7}1@Component2@Aspect3@RequiredArgsConstructor4......