response.setHeader("Cache-Control", "max-age=3600, public"); // 緩存一小時(shí)

response.setDateHeader("Expires", System.currentTimeMillis() + 3600 * 1000); // 緩存一小時(shí)

String etag = generateETagForContent(); // 根據(jù)內(nèi)容生成ETagresponse.setHeader("ETag", etag);

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

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
       throws IOException, ServletException {
   HttpServletResponse httpResponse = (HttpServletResponse) response;
   // 設(shè)置緩存策略
   httpResponse.setHeader("Cache-Control", "max-age=3600");
   // 其他響應(yīng)頭設(shè)置...
   chain.doFilter(request, response);
}

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

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

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

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

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>com.github.ben-manes.caffeine</groupId>
        <artifactId>caffeine</artifactId>
    </dependency>
    <!-- 其他依賴 -->
</dependencies>

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password:
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 500
        min-idle: 0
    lettuce:
      shutdown-timeout: 0

/**
 * 本地緩存Caffeine配置類
 */
@Configuration
public class LocalCacheConfiguration {
    @Bean("localCacheManager")
    public Cache<String, Object> localCacheManager() {
        return Caffeine.newBuilder()
                //寫入或者更新5s后，緩存過(guò)期并失效, 實(shí)際項(xiàng)目中肯定不會(huì)那么短時(shí)間就過(guò)期，根據(jù)具體情況設(shè)置即可
                .expireAfterWrite(5, TimeUnit.SECONDS)
                // 初始的緩存空間大小
                .initialCapacity(50)
                // 緩存的最大條數(shù)，通過(guò) Window TinyLfu算法控制整個(gè)緩存大小
                .maximumSize(500)
            	//打開數(shù)據(jù)收集功能
                .recordStats()
                .build();
    }
}

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //關(guān)聯(lián)
        template.setConnectionFactory(factory);
        //設(shè)置key的序列化方式
//        template.setKeySerializer();
        //設(shè)置value的序列化方式
//        template.setValueSerializer();
        return template;
    }
}

public interface UserService {
    void add(User user);
    User getById(String id);
    User update(User user);
    void deleteById(String id);
}

import com.alibaba.fastjson.JSON;
import com.github.benmanes.caffeine.cache.Cache;
import com.wsh.springboot_caffeine.entity.User;
import com.wsh.springboot_caffeine.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
@Service
public class UserServiceImpl implements UserService {
    /**
     * 模擬數(shù)據(jù)庫(kù)存儲(chǔ)數(shù)據(jù)
     */
    private static HashMap<String, User> userMap = new HashMap<>();
    private final RedisTemplate<String, Object> redisTemplate;
    private final Cache<String, Object> caffeineCache;
    @Autowired
    public UserServiceImpl(RedisTemplate<String, Object> redisTemplate,
                           @Qualifier("localCacheManager") Cache<String, Object> caffeineCache) {
        this.redisTemplate = redisTemplate;
        this.caffeineCache = caffeineCache;
    }
    static {
        userMap.put("1", new User("1", "zhangsan"));
        userMap.put("2", new User("2", "lisi"));
        userMap.put("3", new User("3", "wangwu"));
        userMap.put("4", new User("4", "zhaoliu"));
    }
    @Override
    public void add(User user) {
        // 1.保存Caffeine緩存
        caffeineCache.put(user.getId(), user);
        // 2.保存redis緩存
        redisTemplate.opsForValue().set(user.getId(), JSON.toJSONString(user), 20, TimeUnit.SECONDS);
        // 3.保存數(shù)據(jù)庫(kù)(模擬)
        userMap.put(user.getId(), user);
    }
    @Override
    public User getById(String id) {
        // 1.先從Caffeine緩存中讀取
        Object o = caffeineCache.getIfPresent(id);
        if (Objects.nonNull(o)) {
            System.out.println("從Caffeine中查詢到數(shù)據(jù)...");
            return (User) o;
        }
        // 2.如果緩存中不存在，則從Redis緩存中查找
        String jsonString = (String) redisTemplate.opsForValue().get(id);
        User user = JSON.parseObject(jsonString, User.class);
        if (Objects.nonNull(user)) {
            System.out.println("從Redis中查詢到數(shù)據(jù)...");
            // 保存Caffeine緩存
            caffeineCache.put(user.getId(), user);
            return user;
        }
        // 3.如果Redis緩存中不存在，則從數(shù)據(jù)庫(kù)中查詢
        user = userMap.get(id);
        if (Objects.nonNull(user)) {
            // 保存Caffeine緩存
            caffeineCache.put(user.getId(), user);
            // 保存Redis緩存,20s后過(guò)期
            redisTemplate.opsForValue().set(user.getId(), JSON.toJSONString(user), 20, TimeUnit.SECONDS);
        }
        System.out.println("從數(shù)據(jù)庫(kù)中查詢到數(shù)據(jù)...");
        return user;
    }
    @Override
    public User update(User user) {
        User oldUser = userMap.get(user.getId());
        oldUser.setName(user.getName());
        // 1.更新數(shù)據(jù)庫(kù)
        userMap.put(oldUser.getId(), oldUser);
        // 2.更新Caffeine緩存
        caffeineCache.put(oldUser.getId(), oldUser);
        // 3.更新Redis數(shù)據(jù)庫(kù)
        redisTemplate.opsForValue().set(oldUser.getId(), JSON.toJSONString(oldUser), 20, TimeUnit.SECONDS);
        return oldUser;
    }
    @Override
    public void deleteById(String id) {
        // 1.刪除數(shù)據(jù)庫(kù)
        userMap.remove(id);
        // 2.刪除Caffeine緩存
        caffeineCache.invalidate(id);
        // 3.刪除Redis緩存
        redisTemplate.delete(id);
    }
}