JAVA REST 接口返回慢？使用 Cache-Control 与 ETag 优化响应速度

Java REST 接口性能优化：Cache-Control 与 ETag 的妙用

各位朋友，大家好！今天我们来聊聊 Java REST 接口性能优化的话题，重点是如何利用 Cache-Control 和 ETag 来提升响应速度。相信大家都遇到过 REST 接口响应慢的情况，这会直接影响用户体验，甚至可能导致服务崩溃。缓存是解决这类问题的常用手段，而 Cache-Control 和 ETag 则是 HTTP 协议中用于控制缓存行为的重要头部信息。

一、缓存的重要性：为什么你的接口需要缓存？

想象一下，你的 REST 接口负责返回用户个人资料。每次用户访问个人页面，你的服务器都要查询数据库、处理数据，然后将结果返回给客户端。如果用户频繁刷新页面，或者多个用户同时访问，服务器的压力会非常大。

缓存就像是服务器的“小抄”，它可以将一些不经常变化的数据存储在内存或者其他介质中。当客户端再次请求相同的数据时，服务器可以直接从缓存中读取，而无需重复执行耗时的数据库查询等操作。

缓存带来的好处显而易见：

• 降低服务器负载： 减少数据库查询、计算等操作，减轻服务器压力。
• 提升响应速度： 从缓存中读取数据比从数据库中读取数据快得多。
• 改善用户体验： 更快的响应速度意味着更流畅的用户体验。

二、HTTP 缓存机制：Cache-Control 与 ETag 的作用

HTTP 协议定义了一套完整的缓存机制，其中 Cache-Control 和 ETag 是两个核心的头部信息。

2.1 Cache-Control：控制缓存行为

Cache-Control 头部用于指示浏览器或者中间代理服务器如何缓存响应。它包含一系列指令，常用的指令包括：

指令	含义
public	允许任何缓存（包括浏览器和中间代理服务器）缓存响应。
private	只允许浏览器缓存响应，不允许中间代理服务器缓存。通常用于用户特定数据，例如个人资料。
no-cache	强制每次请求都向服务器验证缓存的有效性。服务器可能会返回 304 Not Modified，表示缓存仍然有效，客户端可以继续使用缓存。
no-store	禁止任何缓存存储响应。
max-age=seconds	指定缓存的有效期，单位为秒。在有效期内，浏览器可以直接从缓存中读取响应，无需向服务器发送请求。
s-maxage=seconds	类似于 max-age，但只适用于共享缓存（例如，中间代理服务器）。
must-revalidate	强制缓存必须在每次使用之前向服务器验证缓存的有效性。与 no-cache 类似，但更严格。

2.2 ETag：验证缓存有效性

ETag 头部用于标识资源的特定版本。当客户端发送请求时，如果发现响应中包含 ETag 头部，它会将 ETag 的值保存下来。当客户端再次请求相同的资源时，它会在请求头中添加 If-None-Match 头部，并将之前保存的 ETag 值作为 If-None-Match 的值发送给服务器。

服务器收到请求后，会比较 If-None-Match 的值与当前资源的 ETag 值。如果两个值相同，说明资源没有发生变化，服务器会返回 304 Not Modified 响应，告诉客户端可以使用缓存。如果两个值不同，说明资源已经发生变化，服务器会返回新的资源和新的 ETag 值。

ETag 的值可以是资源的哈希值、版本号或其他能够唯一标识资源版本的信息。

三、Java REST 接口中如何使用 Cache-Control 和 ETag

接下来，我们通过一个具体的例子来说明如何在 Java REST 接口中使用 Cache-Control 和 ETag。

假设我们有一个 REST 接口 /users/{id}，用于返回用户信息。

3.1 添加 Cache-Control 头部

我们可以使用 Spring Framework 提供的 ResponseEntity 来设置 Cache-Control 头部。

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.getUserById(id);

        if (user == null) {
            return ResponseEntity.notFound().build();
        }

        CacheControl cacheControl = CacheControl.maxAge(60, TimeUnit.SECONDS)
                .cachePublic();

        return ResponseEntity.ok()
                .cacheControl(cacheControl)
                .body(user);
    }
}

在上面的代码中，我们使用了 CacheControl.maxAge(60, TimeUnit.SECONDS) 来设置缓存的有效期为 60 秒，并使用了 cachePublic() 指令，允许任何缓存缓存响应。

3.2 添加 ETag 头部

为了添加 ETag 头部，我们需要计算资源的 ETag 值。一种简单的方法是使用资源的哈希值。

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id, HttpServletRequest request) {
        User user = userService.getUserById(id);

        if (user == null) {
            return ResponseEntity.notFound().build();
        }

        String etag = generateETag(user);

        // 检查客户端是否提供了 If-None-Match 头部
        String ifNoneMatch = request.getHeader("If-None-Match");
        if (ifNoneMatch != null && ifNoneMatch.equals(etag)) {
            return ResponseEntity.status(HttpStatus.NOT_MODIFIED).eTag(etag).build();
        }

        CacheControl cacheControl = CacheControl.maxAge(60, TimeUnit.SECONDS)
                .cachePublic();

        return ResponseEntity.ok()
                .cacheControl(cacheControl)
                .eTag(etag)
                .body(user);
    }

    private String generateETag(User user) {
        // 可以使用任何哈希算法，例如 MD5 或 SHA-256
        String data = user.getId() + user.getName() + user.getEmail();
        return """ + DigestUtils.md5DigestAsHex(data.getBytes()) + """; // ETag 必须用双引号包裹
    }
}

在上面的代码中，我们首先计算了用户的 ETag 值，然后检查客户端是否提供了 If-None-Match 头部。如果 If-None-Match 的值与 ETag 值相同，说明资源没有发生变化，我们返回 304 Not Modified 响应，并设置 ETag 头部。如果 If-None-Match 的值与 ETag 值不同，说明资源已经发生变化，我们返回新的用户数据，并设置新的 ETag 头部。

3.3 UserService 示例

@Service
public class UserService {

    // 模拟数据库
    private static final Map<Long, User> users = new HashMap<>();

    static {
        users.put(1L, new User(1L, "Alice", "[email protected]"));
        users.put(2L, new User(2L, "Bob", "[email protected]"));
    }

    public User getUserById(Long id) {
        return users.get(id);
    }

    public void updateUser(User user) {
        users.put(user.getId(), user);
    }
}

3.4 User 示例

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private Long id;
    private String name;
    private String email;
}

四、更精细的控制：Last-Modified 和 If-Modified-Since

除了 ETag 和 If-None-Match，HTTP 协议还提供了 Last-Modified 和 If-Modified-Since 头部，用于基于时间戳验证缓存的有效性。

• Last-Modified：服务器在响应中返回资源的最后修改时间。
• If-Modified-Since：客户端在请求中发送上次接收到的 Last-Modified 值。

服务器收到请求后，会比较 If-Modified-Since 的值与当前资源的最后修改时间。如果 If-Modified-Since 的值小于等于当前资源的最后修改时间，说明资源已经发生变化，服务器会返回新的资源。否则，服务器会返回 304 Not Modified 响应。

虽然 Last-Modified 和 If-Modified-Since 使用起来比较简单，但它们存在一些局限性：

• 时间精度问题： 时间戳的精度可能不够，导致误判。
• 时钟同步问题： 服务器和客户端的时钟可能存在差异，导致误判。

因此，在实际应用中，ETag 和 If-None-Match 通常比 Last-Modified 和 If-Modified-Since 更可靠。

五、缓存策略的选择：哪种方式更适合你？

选择合适的缓存策略需要考虑多种因素，例如数据的变化频率、敏感程度、缓存的存储位置等。

• 静态资源： 对于静态资源（例如，图片、CSS 文件、JavaScript 文件），可以使用 Cache-Control: max-age=... 指令设置较长的缓存有效期，并使用 CDN 加速访问。
• 动态数据： 对于动态数据（例如，用户信息、商品信息），可以使用 Cache-Control: no-cache 指令强制每次请求都向服务器验证缓存的有效性，并使用 ETag 或 Last-Modified 头部进行验证。
• 敏感数据： 对于敏感数据（例如，用户密码、银行账号），应该使用 Cache-Control: private, no-store 指令禁止任何缓存存储响应。

六、缓存失效策略：如何更新缓存？

缓存失效是缓存管理中一个重要的问题。当数据发生变化时，我们需要及时更新缓存，以保证数据的准确性。

常见的缓存失效策略包括：

• 基于时间的失效： 设置缓存的有效期，当缓存过期时，自动失效。
• 基于事件的失效： 当数据发生变化时，手动失效缓存。例如，当用户更新个人资料时，我们可以手动失效该用户的缓存。
• 基于策略的失效： 使用一定的策略来判断缓存是否需要失效。例如，可以使用 Least Recently Used (LRU) 算法来淘汰最久未使用的缓存。

七、常见的缓存问题及解决方案

• 缓存穿透： 指请求一个不存在的数据，导致缓存失效，每次请求都直接访问数据库。解决方案：
  • 缓存空对象： 当数据库中不存在该数据时，缓存一个空对象，防止每次请求都穿透到数据库。
  • 布隆过滤器： 使用布隆过滤器快速判断数据是否存在，避免访问数据库。
• 缓存雪崩： 指大量缓存同时失效，导致所有请求都直接访问数据库，造成数据库压力过大。解决方案：
  • 设置不同的失效时间： 避免大量缓存同时失效。
  • 使用多级缓存： 使用本地缓存和分布式缓存等多级缓存，降低数据库压力。
  • 熔断降级： 当数据库压力过大时，进行熔断降级，避免服务崩溃。
• 缓存击穿： 指一个热点数据失效，导致大量请求同时访问数据库，造成数据库压力过大。解决方案：
  • 互斥锁： 使用互斥锁保证只有一个请求可以访问数据库，其他请求等待。
  • 永不过期的缓存： 将热点数据设置为永不过期，避免失效。

八、代码示例：Spring Interceptor 实现 ETag 自动生成

为了更方便地在 REST 接口中添加 ETag 头部，我们可以使用 Spring Interceptor 来自动生成 ETag。

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.util.DigestUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

@Component
public class ETagInterceptor implements HandlerInterceptor {

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        if (response.getStatus() == HttpServletResponse.SC_OK && response.getHeader("ETag") == null) {
            // 获取响应体内容，需要包装 HttpServletResponse
            ContentCachingHttpServletResponseWrapper responseWrapper = (ContentCachingHttpServletResponseWrapper) response;
            byte[] body = responseWrapper.getContentAsByteArray();

            if (body.length > 0) {
                String etag = generateETag(body);
                response.setHeader("ETag", etag);

                // 检查 If-None-Match
                String ifNoneMatch = request.getHeader("If-None-Match");
                if (ifNoneMatch != null && ifNoneMatch.equals(etag)) {
                    response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                    // 清空响应体，避免返回数据
                    responseWrapper.resetBuffer();
                } else {
                    // 将缓存的响应体写回
                    responseWrapper.copyBodyToResponse();
                }
            }
        }
    }

    private String generateETag(byte[] body) {
        return """ + DigestUtils.md5DigestAsHex(body) + """;
    }
}

需要注意的是，为了获取响应体的内容，我们需要使用 ContentCachingHttpServletResponseWrapper 包装 HttpServletResponse。

import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class ContentCachingHttpServletResponseWrapper extends HttpServletResponseWrapper {

    private ByteArrayOutputStream cachedBytes = new ByteArrayOutputStream();
    private HttpServletResponse response;

    public ContentCachingHttpServletResponseWrapper(HttpServletResponse response) {
        super(response);
        this.response = response;
    }

    @Override
    public OutputStream getOutputStream() throws IOException {
        return new TeeOutputStream(response.getOutputStream(), cachedBytes);
    }

    public byte[] getContentAsByteArray() {
        return cachedBytes.toByteArray();
    }

    public void copyBodyToResponse() throws IOException {
        byte[] cachedContent = cachedBytes.toByteArray();
        response.getOutputStream().write(cachedContent);
    }

    public void resetBuffer() {
        cachedBytes.reset();
    }
}

然后，我们需要配置 Interceptor。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Autowired
    private ETagInterceptor eTagInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(eTagInterceptor).addPathPatterns("/**");
    }
}

最后，我们需要配置 Filter，将 HttpServletResponse 包装成 ContentCachingHttpServletResponseWrapper。

import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class ResponseCachingFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        ContentCachingHttpServletResponseWrapper responseWrapper = new ContentCachingHttpServletResponseWrapper(httpResponse);
        chain.doFilter(request, responseWrapper);

    }
}

九、总结与建议

今天我们深入探讨了如何使用 Cache-Control 和 ETag 来优化 Java REST 接口的性能。希望通过今天的讲解，大家能够更好地理解 HTTP 缓存机制，并将其应用到实际项目中。记住，缓存策略的选择需要根据实际情况进行调整，没有一成不变的方案。

缓存是提升性能的利器，选择合适的策略至关重要。

充分利用 HTTP 头部信息，优化你的 REST 接口性能。

时刻关注缓存失效问题，保证数据的准确性和一致性。