架构之静态资源缓存

静态资源缓存架构优化

原创于 2025-12-11 13:58:42 发布 · 373 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#架构 #缓存 #静态资源

Architect 专栏收录该内容

18 篇文章

订阅专栏

架构之静态资源缓存

引言

在现代Web应用中，静态资源（如图片、CSS、JavaScript、字体等）通常占据了页面加载时间的绝大部分。据统计，静态资源平均占页面总加载时间的80%以上。通过合理的静态资源缓存策略，可以显著减少页面加载时间，提升用户体验，降低服务器负载和带宽成本。

静态资源缓存法则强调：通过动静分离、多级缓存架构（Nginx文件缓存 + CDN分发），实现静态资源的高效缓存和快速分发，在保证资源实时性的同时，最大化缓存命中率和访问性能。这不仅是对性能优化的要求，更是对用户体验的保障。

静态资源缓存的核心理念

什么是静态资源？

静态资源是指内容相对固定、不经常变化的文件资源，主要包括：

静态资源的特点

缓存带来的价值

动静分离架构设计

动静分离的基本原则

动静分离是静态资源缓存的前提，通过将动态内容和静态内容分离处理，实现不同的优化策略。

域名分离策略

# Nginx动静分离配置示例
# 动态内容域名配置
server {
    listen 80;
    server_name api.example.com;
    
    # 动态内容处理
    location / {
        proxy_pass http://backend_servers;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        
        # 动态内容缓存策略
        add_header Cache-Control "no-cache, no-store, must-revalidate";
        add_header Pragma "no-cache";
        add_header Expires "0";
    }
}

# 静态资源域名配置
server {
    listen 80;
    server_name static.example.com;
    
    # 开启高效文件传输模式
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    
    # 静态资源处理
    location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff|woff2|ttf|svg|eot)$ {
        root /var/www/static;
        
        # 设置强缓存
        expires 1y;
        add_header Cache-Control "public, immutable";
        
        # 开启GZIP压缩
        gzip on;
        gzip_types text/css application/javascript image/svg+xml;
        
        # 添加CORS头
        add_header Access-Control-Allow-Origin "*";
    }
    
    # 图片资源特殊处理
    location ~* \.(jpg|jpeg|png|gif|webp|avif)$ {
        # 图片优化
        add_header Vary "Accept-Encoding";
        
        # WebP支持检测
        if ($http_accept ~* "webp") {
            set $webp_accept "true";
        }
        
        # 根据客户端支持返回不同格式
        try_files $uri$webp_suffix $uri =404;
    }
}

静态资源服务器架构

// Spring Boot静态资源配置
@Configuration
public class StaticResourceConfig implements WebMvcConfigurer {
    
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        // 配置静态资源映射
        registry.addResourceHandler("/static/**")
                .addResourceLocations("classpath:/static/")
                .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS)
                        .cachePublic()
                        .immutable())
                .resourceChain(true)
                .addResolver(new VersionResourceResolver()
                        .addContentVersionStrategy("/**"))
                .addTransformer(new CssLinkResourceTransformer());
        
        // 图片资源特殊处理
        registry.addResourceHandler("/images/**")
                .addResourceLocations("classpath:/static/images/")
                .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS)
                        .cachePublic())
                .resourceChain(true)
                .addResolver(new WebJarsResourceResolver());
        
        // WebJars资源处理
        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/")
                .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS)
                        .cachePublic()
                        .immutable());
    }
    
    // 配置静态资源版本管理
    @Bean
    public ResourceUrlEncodingFilter resourceUrlEncodingFilter() {
        return new ResourceUrlEncodingFilter();
    }
}

Nginx文件缓存架构

Nginx缓存机制设计

Nginx提供了强大的文件缓存功能，通过合理的配置可以显著提升静态资源的访问性能。

Nginx文件缓存配置

# Nginx文件缓存高级配置
http {
    # 文件缓存配置
    open_file_cache max=200000 inactive=20s;
    open_file_cache_valid 30s;
    open_file_cache_min_uses 2;
    open_file_cache_errors on;
    
    # 代理缓存配置
    proxy_cache_path /var/cache/nginx/proxy levels=1:2 keys_zone=proxy_cache:100m inactive=60m max_size=10g;
    
    # 压缩缓存配置
    gzip_static on;
    gzip_proxied any;
    gzip_vary on;
    gzip_comp_level 6;
    gzip_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/javascript
        application/xml+rss
        application/json
        image/svg+xml;
    
    server {
        listen 80;
        server_name static.example.com;
        
        # 静态资源缓存配置
        location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff|woff2|ttf|svg|eot)$ {
            root /var/www/static;
            
            # 强缓存配置
            expires 1y;
            add_header Cache-Control "public, immutable";
            add_header Vary "Accept-Encoding";
            
            # 文件缓存优化
            open_file_cache max=100000 inactive=30s;
            open_file_cache_valid 60s;
            open_file_cache_min_uses 1;
            open_file_cache_errors off;
            
            # 开启高效传输
            sendfile on;
            tcp_nopush on;
            tcp_nodelay on;
            
            # 预压缩文件支持
            gzip_static on;
            
            # 访问日志关闭
            access_log off;
            
            # 错误页面处理
            error_page 404 = @static_404;
        }
        
        # 404错误处理
        location @static_404 {
            internal;
            return 404 '{"error": "Resource not found", "code": 404}';
        }
        
        # 图片特殊处理
        location ~* \.(jpg|jpeg|png|gif|webp)$ {
            root /var/www/static/images;
            
            # 图片压缩
            image_filter resize 1920 -;
            image_filter_jpeg_quality 85;
            image_filter_webp_quality 80;
            
            # 图片缓存
            expires 1y;
            add_header Cache-Control "public, immutable";
            
            # WebP格式支持
            if ($http_accept ~* "webp") {
                add_header Vary "Accept";
                try_files $uri$webp_suffix $uri =404;
            }
        }
        
        # CSS/JS文件处理
        location ~* \.(css|js)$ {
            root /var/www/static;
            
            # 压缩传输
            gzip on;
            gzip_types text/css application/javascript;
            gzip_min_length 1000;
            
            # 长期缓存
            expires 1y;
            add_header Cache-Control "public, immutable";
            
            # 版本控制
            location ~* \.(css|js)\.v[0-9]+\.(css|js)$ {
                expires 1y;
                add_header Cache-Control "public, immutable";
            }
        }
        
        # 字体文件处理
        location ~* \.(woff|woff2|ttf|otf|eot)$ {
            root /var/www/static/fonts;
            
            # CORS头
            add_header Access-Control-Allow-Origin "*";
            add_header Access-Control-Allow-Methods "GET, OPTIONS";
            add_header Access-Control-Allow-Headers "DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type";
            
            # 长期缓存
            expires 1y;
            add_header Cache-Control "public, immutable";
        }
    }
}

Nginx缓存性能优化

# Nginx缓存性能优化配置
http {
    # 工作进程优化
    worker_processes auto;
    worker_rlimit_nofile 65535;
    
    events {
        worker_connections 65535;
        use epoll;
        multi_accept on;
    }
    
    # HTTP性能优化
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    keepalive_requests 1000;
    
    # 文件缓存优化
    open_file_cache max=200000 inactive=20s;
    open_file_cache_valid 30s;
    open_file_cache_min_uses 2;
    open_file_cache_errors on;
    
    # 客户端缓存优化
    map $sent_http_content_type $expires {
        default                    1M;
        text/html                  epoch;
        text/css                   1y;
        application/javascript     1y;
        ~image/                    1y;
        ~font/                     1y;
    }
    
    server {
        listen 80;
        server_name static.example.com;
        
        # 应用缓存控制
        expires $expires;
        
        # 静态资源处理
        location ~* \.(?:css|js|jpe?g|png|gif|ico|cur|heic|webp|tiff?|mp3|m4a|aac|ogg|midi?|wav|mp4|mov|webm|mpe?g|avi|ogv|flv|wmv)$ {
            root /var/www/static;
            
            # 强缓存
            add_header Cache-Control "public, immutable";
            
            # 预压缩支持
            gzip_static on;
            
            # 文件缓存
            open_file_cache max=100000 inactive=30s;
            open_file_cache_valid 60s;
            
            # 访问日志关闭
            access_log off;
            
            # 添加文件类型头
            add_header X-Content-Type-Options "nosniff";
            
            # 安全头
            add_header X-Frame-Options "SAMEORIGIN";
            add_header X-XSS-Protection "1; mode=block";
        }
        
        # 缓存清理接口（需要限制访问）
        location ~ /purge(/.*) {
            allow 127.0.0.1;
            allow 10.0.0.0/8;
            deny all;
            
            proxy_cache_purge proxy_cache $1$is_args$args;
        }
    }
}

CDN缓存架构设计

CDN架构原理

CDN（Content Delivery Network）通过在全球部署边缘节点，将静态资源缓存到离用户最近的位置，实现快速访问。

CDN缓存策略设计

// CDN缓存策略配置
@Configuration
public class CDNConfig {
    
    @Value("${cdn.enabled:true}")
    private boolean cdnEnabled;
    
    @Value("${cdn.domain:cdn.example.com}")
    private String cdnDomain;
    
    @Value("${cdn.cache-control.max-age:31536000}")
    private int maxAge;
    
    // CDN URL生成器
    @Component
    public class CDNUrlBuilder {
        
        public String buildCDNUrl(String resourcePath) {
            if (!cdnEnabled) {
                return resourcePath;
            }
            
            // 构建CDN URL
            StringBuilder cdnUrl = new StringBuilder();
            cdnUrl.append("https://").append(cdnDomain);
            
            // 添加版本号参数
            if (resourcePath.contains("?")) {
                cdnUrl.append(resourcePath).append("&v=").append(getResourceVersion(resourcePath));
            } else {
                cdnUrl.append(resourcePath).append("?v=").append(getResourceVersion(resourcePath));
            }
            
            return cdnUrl.toString();
        }
        
        private String getResourceVersion(String resourcePath) {
            // 根据文件内容生成版本号
            return String.valueOf(getFileLastModified(resourcePath));
        }
        
        private long getFileLastModified(String resourcePath) {
            // 获取文件最后修改时间
            try {
                Resource resource = resourceLoader.getResource("classpath:static" + resourcePath);
                return resource.lastModified();
            } catch (IOException e) {
                return System.currentTimeMillis();
            }
        }
    }
    
    // 静态资源版本管理
    @Component
    public class StaticResourceVersionManager {
        
        private final Map<String, String> resourceVersions = new ConcurrentHashMap<>();
        
        @PostConstruct
        public void init() {
            // 初始化资源版本信息
            scanAndUpdateVersions();
        }
        
        public String getVersionedUrl(String resourcePath) {
            String version = resourceVersions.get(resourcePath);
            if (version == null) {
                version = calculateVersion(resourcePath);
                resourceVersions.put(resourcePath, version);
            }
            
            if (cdnEnabled) {
                return buildCDNUrl(resourcePath, version);
            } else {
                return buildLocalUrl(resourcePath, version);
            }
        }
        
        private String calculateVersion(String resourcePath) {
            // 基于文件内容计算版本号
            try {
                Resource resource = resourceLoader.getResource("classpath:static" + resourcePath);
                if (resource.exists()) {
                    // 使用文件MD5作为版本号
                    return calculateMD5(resource);
                }
            } catch (IOException e) {
                log.error("Failed to calculate version for resource: " + resourcePath, e);
            }
            
            // 回退到时间戳
            return String.valueOf(System.currentTimeMillis());
        }
        
        private String calculateMD5(Resource resource) throws IOException {
            // 计算文件MD5值
            try (InputStream is = resource.getInputStream()) {
                MessageDigest md = MessageDigest.getInstance("MD5");
                byte[] buffer = new byte[8192];
                int read;
                while ((read = is.read(buffer)) != -1) {
                    md.update(buffer, 0, read);
                }
                byte[] digest = md.digest();
                return bytesToHex(digest);
            } catch (NoSuchAlgorithmException e) {
                throw new RuntimeException("MD5 algorithm not available", e);
            }
        }
        
        private String bytesToHex(byte[] bytes) {
            StringBuilder result = new StringBuilder();
            for (byte b : bytes) {
                result.append(String.format("%02x", b));
            }
            return result.toString().substring(0, 8); // 取前8位
        }
        
        private String buildCDNUrl(String resourcePath, String version) {
            return "https://" + cdnDomain + resourcePath + "?v=" + version;
        }
        
        private String buildLocalUrl(String resourcePath, String version) {
            return resourcePath + "?v=" + version;
        }
        
        public void scanAndUpdateVersions() {
            // 扫描静态资源目录，更新版本信息
            try {
                Resource resource = resourceLoader.getResource("classpath:static");
                if (resource.exists()) {
                    File staticDir = resource.getFile();
                    scanDirectory(staticDir, "");
                }
            } catch (IOException e) {
                log.error("Failed to scan static resources", e);
            }
        }
        
        private void scanDirectory(File dir, String path) {
            File[] files = dir.listFiles();
            if (files != null) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        scanDirectory(file, path + "/" + file.getName());
                    } else {
                        String resourcePath = path + "/" + file.getName();
                        String version = calculateVersion(resourcePath);
                        resourceVersions.put(resourcePath, version);
                    }
                }
            }
        }
    }
}

CDN缓存控制策略

// CDN缓存控制器
@RestController
@RequestMapping("/api/cdn")
public class CDNCacheController {
    
    @Autowired
    private CDNService cdnService;
    
    // 缓存预热接口
    @PostMapping("/preload")
    public ResponseEntity<CDNResponse> preloadResources(@RequestBody List<String> resourceUrls) {
        try {
            List<String> preloadedUrls = cdnService.preloadResources(resourceUrls);
            return ResponseEntity.ok(new CDNResponse(true, "Resources preloaded successfully", preloadedUrls));
        } catch (Exception e) {
            log.error("Failed to preload resources", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(new CDNResponse(false, "Failed to preload resources: " + e.getMessage(), null));
        }
    }
    
    // 缓存刷新接口
    @PostMapping("/refresh")
    public ResponseEntity<CDNResponse> refreshResources(@RequestBody List<String> resourceUrls) {
        try {
            List<String> refreshedUrls = cdnService.refreshResources(resourceUrls);
            return ResponseEntity.ok(new CDNResponse(true, "Resources refreshed successfully", refreshedUrls));
        } catch (Exception e) {
            log.error("Failed to refresh resources", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(new CDNResponse(false, "Failed to refresh resources: " + e.getMessage(), null));
        }
    }
    
    // 缓存查询接口
    @GetMapping("/cache-status")
    public ResponseEntity<CacheStatusResponse> getCacheStatus(@RequestParam String resourceUrl) {
        try {
            CacheStatus status = cdnService.getCacheStatus(resourceUrl);
            return ResponseEntity.ok(new CacheStatusResponse(status));
        } catch (Exception e) {
            log.error("Failed to get cache status", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(new CacheStatusResponse(null));
        }
    }
}

// CDN服务实现
@Service
public class CDNService {
    
    @Value("${cdn.provider:aliyun}")
    private String cdnProvider;
    
    @Autowired
    private CDNProviderFactory cdnProviderFactory;
    
    public List<String> preloadResources(List<String> resourceUrls) {
        CDNProvider provider = cdnProviderFactory.getProvider(cdnProvider);
        return provider.preload(resourceUrls);
    }
    
    public List<String> refreshResources(List<String> resourceUrls) {
        CDNProvider provider = cdnProviderFactory.getProvider(cdnProvider);
        return provider.refresh(resourceUrls);
    }
    
    public CacheStatus getCacheStatus(String resourceUrl) {
        CDNProvider provider = cdnProviderFactory.getProvider(cdnProvider);
        return provider.getCacheStatus(resourceUrl);
    }
}

// CDN提供商接口
public interface CDNProvider {
    List<String> preload(List<String> urls);
    List<String> refresh(List<String> urls);
    CacheStatus getCacheStatus(String url);
}

// 阿里云CDN实现
@Component
public class AliyunCDNProvider implements CDNProvider {
    
    @Autowired
    private AliyunCDNClient cdnClient;
    
    @Override
    public List<String> preload(List<String> urls) {
        // 调用阿里云CDN预热API
        return cdnClient.pushObjectCache(urls);
    }
    
    @Override
    public List<String> refresh(List<String> urls) {
        // 调用阿里云CDN刷新API
        return cdnClient.refreshObjectCaches(urls);
    }
    
    @Override
    public CacheStatus getCacheStatus(String url) {
        // 查询CDN缓存状态
        return cdnClient.describeCachedObjects(url);
    }
}

缓存策略与优化

缓存控制策略

// 缓存控制策略配置
@Configuration
public class CacheControlConfig {
    
    // HTTP缓存控制头配置
    @Bean
    public FilterRegistrationBean<CacheControlFilter> cacheControlFilter() {
        FilterRegistrationBean<CacheControlFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new CacheControlFilter());
        registration.addUrlPatterns("/static/*");
        registration.setOrder(1);
        return registration;
    }
    
    // 缓存控制过滤器
    public static class CacheControlFilter implements Filter {
        
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, 
                           FilterChain chain) throws IOException, ServletException {
            
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            
            String requestUri = httpRequest.getRequestURI();
            
            // 根据资源类型设置不同的缓存策略
            if (requestUri.matches(".*\\.(css|js)$")) {
                // CSS/JS文件：1年缓存，不可变
                httpResponse.setHeader("Cache-Control", "public, max-age=31536000, immutable");
                httpResponse.setHeader("Expires", getExpiryDate(365));
            } else if (requestUri.matches(".*\\.(jpg|jpeg|png|gif|webp|avif)$")) {
                // 图片文件：1年缓存，不可变
                httpResponse.setHeader("Cache-Control", "public, max-age=31536000, immutable");
                httpResponse.setHeader("Expires", getExpiryDate(365));
            } else if (requestUri.matches(".*\\.(woff|woff2|ttf|eot|otf)$")) {
                // 字体文件：1年缓存，不可变
                httpResponse.setHeader("Cache-Control", "public, max-age=31536000, immutable");
                httpResponse.setHeader("Expires", getExpiryDate(365));
            } else {
                // 其他静态资源：1个月缓存
                httpResponse.setHeader("Cache-Control", "public, max-age=2592000");
                httpResponse.setHeader("Expires", getExpiryDate(30));
            }
            
            // 添加ETag支持
            httpResponse.setHeader("ETag", generateETag(requestUri));
            
            // 添加Last-Modified支持
            httpResponse.setHeader("Last-Modified", getLastModifiedDate(requestUri));
            
            chain.doFilter(request, response);
        }
        
        private String getExpiryDate(int days) {
            return Instant.now().plus(days, ChronoUnit.DAYS)
                    .atOffset(ZoneOffset.UTC)
                    .format(DateTimeFormatter.RFC_1123_DATE_TIME);
        }
        
        private String generateETag(String requestUri) {
            // 基于文件内容生成ETag
            return "\"" + requestUri.hashCode() + "\"";
        }
        
        private String getLastModifiedDate(String requestUri) {
            // 返回当前时间作为最后修改时间
            return Instant.now().atOffset(ZoneOffset.UTC)
                    .format(DateTimeFormatter.RFC_1123_DATE_TIME);
        }
    }
}

缓存失效与更新策略

// 缓存失效管理器
@Component
public class CacheInvalidationManager {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    @Autowired
    private CDNService cdnService;
    
    private static final String CACHE_VERSION_KEY = "static:resource:version:";
    
    // 资源更新时触发缓存失效
    public void invalidateResource(String resourcePath) {
        // 1. 更新版本号
        String newVersion = generateNewVersion();
        redisTemplate.opsForValue().set(CACHE_VERSION_KEY + resourcePath, newVersion);
        
        // 2. 刷新CDN缓存
        List<String> urls = Arrays.asList(
            buildFullUrl(resourcePath),
            buildFullUrl(resourcePath) + "?*"
        );
        cdnService.refreshResources(urls);
        
        // 3. 刷新Nginx缓存（如果启用）
        refreshNginxCache(resourcePath);
        
        log.info("Resource cache invalidated: {}", resourcePath);
    }
    
    // 批量失效
    public void invalidateResources(List<String> resourcePaths) {
        for (String path : resourcePaths) {
            invalidateResource(path);
        }
    }
    
    // 全站缓存失效
    public void invalidateAll() {
        // 1. 清除所有版本号
        Set<String> keys = redisTemplate.keys(CACHE_VERSION_KEY + "*");
        if (keys != null && !keys.isEmpty()) {
            redisTemplate.delete(keys);
        }
        
        // 2. 刷新CDN全站缓存
        cdnService.refreshAll();
        
        // 3. 刷新Nginx缓存
        refreshAllNginxCache();
        
        log.info("All cache invalidated");
    }
    
    // 智能缓存失效
    public void smartInvalidate(String resourcePath) {
        // 分析资源依赖关系
        Set<String> affectedResources = analyzeDependencies(resourcePath);
        
        // 批量失效相关资源
        if (!affectedResources.isEmpty()) {
            invalidateResources(new ArrayList<>(affectedResources));
        }
    }
    
    // 分析资源依赖关系
    private Set<String> analyzeDependencies(String resourcePath) {
        Set<String> dependencies = new HashSet<>();
        
        if (resourcePath.endsWith(".css")) {
            // CSS文件可能影响相关图片资源
            dependencies.addAll(findRelatedImages(resourcePath));
        } else if (resourcePath.endsWith(".js")) {
            // JS文件可能有依赖的其他JS文件
            dependencies.addAll(findRelatedScripts(resourcePath));
        }
        
        dependencies.add(resourcePath);
        return dependencies;
    }
    
    private Set<String> findRelatedImages(String cssPath) {
        // 分析CSS文件中的图片引用
        Set<String> images = new HashSet<>();
        // 实现CSS内容分析逻辑
        return images;
    }
    
    private Set<String> findRelatedScripts(String jsPath) {
        // 分析JS文件的依赖关系
        Set<String> scripts = new HashSet<>();
        // 实现JS依赖分析逻辑
        return scripts;
    }
    
    private String generateNewVersion() {
        return String.valueOf(System.currentTimeMillis());
    }
    
    private String buildFullUrl(String resourcePath) {
        return "https://static.example.com" + resourcePath;
    }
    
    private void refreshNginxCache(String resourcePath) {
        // 调用Nginx缓存清理接口
        // 实现Nginx缓存清理逻辑
    }
    
    private void refreshAllNginxCache() {
        // 清理所有Nginx缓存
        // 实现全站缓存清理逻辑
    }
}

性能监控与优化

缓存性能监控

// 缓存性能监控服务
@Service
public class CachePerformanceMonitor {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    @Autowired
    private CDNService cdnService;
    
    private final Counter cacheHitCounter;
    private final Counter cacheMissCounter;
    private final Timer cacheResponseTimer;
    private final Gauge cacheHitRateGauge;
    
    public CachePerformanceMonitor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        // 初始化监控指标
        this.cacheHitCounter = Counter.builder("cache.hit.count")
                .description("Number of cache hits")
                .register(meterRegistry);
                
        this.cacheMissCounter = Counter.builder("cache.miss.count")
                .description("Number of cache misses")
                .register(meterRegistry);
                
        this.cacheResponseTimer = Timer.builder("cache.response.time")
                .description("Cache response time")
                .register(meterRegistry);
                
        this.cacheHitRateGauge = Gauge.builder("cache.hit.rate")
                .description("Cache hit rate percentage")
                .register(meterRegistry, this, CachePerformanceMonitor::calculateHitRate);
    }
    
    // 记录缓存命中
    public void recordCacheHit(String resourceType, String cacheLevel) {
        cacheHitCounter.increment("type", resourceType, "level", cacheLevel);
        
        // 记录详细日志
        log.debug("Cache hit - Type: {}, Level: {}", resourceType, cacheLevel);
    }
    
    // 记录缓存未命中
    public void recordCacheMiss(String resourceType, String reason) {
        cacheMissCounter.increment("type", resourceType, "reason", reason);
        
        // 记录详细日志
        log.debug("Cache miss - Type: {}, Reason: {}", resourceType, reason);
    }
    
    // 记录响应时间
    public void recordResponseTime(String resourceType, long responseTimeMs) {
        cacheResponseTimer.record(responseTimeMs, TimeUnit.MILLISECONDS, "type", resourceType);
    }
    
    // 计算缓存命中率
    private double calculateHitRate() {
        double hits = cacheHitCounter.count();
        double misses = cacheMissCounter.count();
        double total = hits + misses;
        
        return total > 0 ? (hits / total) * 100 : 0;
    }
    
    // 生成性能报告
    public CachePerformanceReport generatePerformanceReport() {
        CachePerformanceReport report = new CachePerformanceReport();
        
        // 收集CDN性能数据
        report.setCdnPerformance(collectCDNPerformance());
        
        // 收集Nginx缓存性能数据
        report.setNginxPerformance(collectNginxPerformance());
        
        // 收集浏览器缓存性能数据
        report.setBrowserCachePerformance(collectBrowserCachePerformance());
        
        // 分析性能瓶颈
        report.setBottlenecks(analyzeBottlenecks());
        
        // 生成优化建议
        report.setRecommendations(generateRecommendations());
        
        return report;
    }
    
    private CDNPerformance collectCDNPerformance() {
        CDNPerformance performance = new CDNPerformance();
        
        // 获取CDN缓存命中率
        double cdnHitRate = cdnService.getCacheHitRate();
        performance.setHitRate(cdnHitRate);
        
        // 获取CDN响应时间
        double avgResponseTime = cdnService.getAverageResponseTime();
        performance.setAverageResponseTime(avgResponseTime);
        
        // 获取CDN带宽使用情况
        BandwidthUsage bandwidth = cdnService.getBandwidthUsage();
        performance.setBandwidthUsage(bandwidth);
        
        return performance;
    }
    
    private NginxPerformance collectNginxPerformance() {
        NginxPerformance performance = new NginxPerformance();
        
        // 获取Nginx缓存状态
        Map<String, Object> nginxStatus = getNginxStatus();
        performance.setCacheHitRate((Double) nginxStatus.get("cache_hit_rate"));
        performance.setActiveConnections((Integer) nginxStatus.get("active_connections"));
        performance.setRequestsPerSecond((Double) nginxStatus.get("requests_per_second"));
        
        return performance;
    }
    
    private BrowserCachePerformance collectBrowserCachePerformance() {
        BrowserCachePerformance performance = new BrowserCachePerformance();
        
        // 分析浏览器缓存命中率
        double browserHitRate = analyzeBrowserCacheHits();
        performance.setHitRate(browserHitRate);
        
        // 分析缓存资源大小
        long cachedResourceSize = getCachedResourceSize();
        performance.setCachedResourceSize(cachedResourceSize);
        
        return performance;
    }
    
    private List<PerformanceBottleneck> analyzeBottlenecks() {
        List<PerformanceBottleneck> bottlenecks = new ArrayList<>();
        
        // 分析CDN性能瓶颈
        double cdnHitRate = cdnService.getCacheHitRate();
        if (cdnHitRate < 80) {
            bottlenecks.add(new PerformanceBottleneck(
                "CDN_HIT_RATE_LOW",
                "CDN缓存命中率过低",
                "当前命中率: " + cdnHitRate + "%，建议优化缓存策略",
                BottleneckSeverity.HIGH
            ));
        }
        
        // 分析响应时间瓶颈
        double avgResponseTime = cdnService.getAverageResponseTime();
        if (avgResponseTime > 200) {
            bottlenecks.add(new PerformanceBottleneck(
                "RESPONSE_TIME_HIGH",
                "平均响应时间过长",
                "当前响应时间: " + avgResponseTime + "ms，建议优化CDN节点分布",
                BottleneckSeverity.MEDIUM
            ));
        }
        
        return bottlenecks;
    }
    
    private List<OptimizationRecommendation> generateRecommendations() {
        List<OptimizationRecommendation> recommendations = new ArrayList<>();
        
        // 基于性能数据生成优化建议
        recommendations.add(new OptimizationRecommendation(
            "CACHE_DURATION_OPTIMIZATION",
            "优化缓存时间",
            "根据资源更新频率调整缓存时间，提高缓存命中率",
            RecommendationPriority.HIGH
        ));
        
        recommendations.add(new OptimizationRecommendation(
            "CDN_NODE_OPTIMIZATION",
            "优化CDN节点分布",
            "在用户集中地区增加CDN节点，降低访问延迟",
            RecommendationPriority.MEDIUM
        ));
        
        return recommendations;
    }
}

缓存优化策略

// 缓存优化服务
@Service
public class CacheOptimizationService {
    
    @Autowired
    private CachePerformanceMonitor performanceMonitor;
    
    @Autowired
    private CDNService cdnService;
    
    // 自动优化缓存配置
    public void autoOptimizeCache() {
        // 1. 收集性能数据
        CachePerformanceReport report = performanceMonitor.generatePerformanceReport();
        
        // 2. 分析性能瓶颈
        List<PerformanceBottleneck> bottlenecks = report.getBottlenecks();
        
        // 3. 执行优化策略
        for (PerformanceBottleneck bottleneck : bottlenecks) {
            executeOptimization(bottleneck);
        }
        
        // 4. 验证优化效果
        validateOptimizationResults();
    }
    
    // 执行具体优化策略
    private void executeOptimization(PerformanceBottleneck bottleneck) {
        switch (bottleneck.getCode()) {
            case "CDN_HIT_RATE_LOW":
                optimizeCDNHitRate();
                break;
            case "RESPONSE_TIME_HIGH":
                optimizeResponseTime();
                break;
            case "CACHE_SIZE_LARGE":
                optimizeCacheSize();
                break;
            default:
                log.warn("Unknown bottleneck: {}", bottleneck.getCode());
        }
    }
    
    // 优化CDN命中率
    private void optimizeCDNHitRate() {
        log.info("Optimizing CDN hit rate...");
        
        // 1. 分析缓存未命中的原因
        Map<String, Integer> missReasons = analyzeCacheMissReasons();
        
        // 2. 根据原因采取相应措施
        for (Map.Entry<String, Integer> entry : missReasons.entrySet()) {
            String reason = entry.getKey();
            int count = entry.getValue();
            
            switch (reason) {
                case "EXPIRED":
                    // 延长缓存时间
                    extendCacheDuration();
                    break;
                case "NOT_CACHED":
                    // 增加缓存覆盖范围
                    expandCacheCoverage();
                    break;
                case "PURGED":
                    // 优化缓存清理策略
                    optimizePurgeStrategy();
                    break;
            }
        }
    }
    
    // 优化响应时间
    private void optimizeResponseTime() {
        log.info("Optimizing response time...");
        
        // 1. 分析响应时间分布
        Map<String, Double> responseTimeDistribution = analyzeResponseTimeDistribution();
        
        // 2. 识别慢响应区域
        List<String> slowRegions = identifySlowRegions(responseTimeDistribution);
        
        // 3. 优化CDN节点分布
        if (!slowRegions.isEmpty()) {
            cdnService.optimizeNodeDistribution(slowRegions);
        }
        
        // 4. 启用更激进的压缩策略
        enableAggressiveCompression();
    }
    
    // 优化缓存大小
    private void optimizeCacheSize() {
        log.info("Optimizing cache size...");
        
        // 1. 分析资源使用频率
        Map<String, Double> resourceUsageFrequency = analyzeResourceUsageFrequency();
        
        // 2. 识别低频资源
        List<String> lowFrequencyResources = identifyLowFrequencyResources(resourceUsageFrequency);
        
        // 3. 调整缓存策略
        for (String resource : lowFrequencyResources) {
            reduceCachePriority(resource);
        }
        
        // 4. 启用智能压缩
        enableSmartCompression();
    }
    
    // 验证优化效果
    private void validateOptimizationResults() {
        log.info("Validating optimization results...");
        
        // 等待一段时间让优化生效
        try {
            Thread.sleep(60000); // 等待1分钟
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        // 重新收集性能数据
        CachePerformanceReport newReport = performanceMonitor.generatePerformanceReport();
        
        // 对比优化前后的性能指标
        boolean improvementDetected = comparePerformanceReports(newReport);
        
        if (improvementDetected) {
            log.info("Cache optimization successful!");
        } else {
            log.warn("No significant improvement detected, further optimization needed");
        }
    }
    
    private boolean comparePerformanceReports(CachePerformanceReport newReport) {
        // 实现性能对比逻辑
        // 返回是否有显著改善
        return true;
    }
    
    // 辅助方法实现
    private Map<String, Integer> analyzeCacheMissReasons() {
        // 实现缓存未命中原因分析
        return new HashMap<>();
    }
    
    private Map<String, Double> analyzeResponseTimeDistribution() {
        // 实现响应时间分布分析
        return new HashMap<>();
    }
    
    private List<String> identifySlowRegions(Map<String, Double> responseTimeDistribution) {
        // 识别响应时间慢的区域
        return new ArrayList<>();
    }
    
    private Map<String, Double> analyzeResourceUsageFrequency() {
        // 分析资源使用频率
        return new HashMap<>();
    }
    
    private List<String> identifyLowFrequencyResources(Map<String, Double> resourceUsageFrequency) {
        // 识别低频使用资源
        return new ArrayList<>();
    }
    
    private void extendCacheDuration() {
        // 延长缓存时间
        log.info("Extending cache duration...");
    }
    
    private void expandCacheCoverage() {
        // 扩大缓存覆盖范围
        log.info("Expanding cache coverage...");
    }
    
    private void optimizePurgeStrategy() {
        // 优化缓存清理策略
        log.info("Optimizing purge strategy...");
    }
    
    private void enableAggressiveCompression() {
        // 启用激进压缩策略
        log.info("Enabling aggressive compression...");
    }
    
    private void reduceCachePriority(String resource) {
        // 降低资源缓存优先级
        log.info("Reducing cache priority for resource: {}", resource);
    }
    
    private void enableSmartCompression() {
        // 启用智能压缩
        log.info("Enabling smart compression...");
    }
}

最佳实践与案例分析

静态资源缓存最佳实践

// 静态资源缓存最佳实践配置
@Configuration
public class StaticResourceBestPractices {
    
    // 最佳实践1：版本化资源管理
    @Component
    public class VersionedResourceManager {
        
        // 使用内容哈希作为版本号
        public String getVersionedUrl(String resourcePath) {
            String contentHash = calculateContentHash(resourcePath);
            return resourcePath + "?v=" + contentHash.substring(0, 8);
        }
        
        private String calculateContentHash(String resourcePath) {
            // 基于文件内容计算哈希值
            try {
                Resource resource = resourceLoader.getResource("classpath:static" + resourcePath);
                if (resource.exists()) {
                    return DigestUtils.md5DigestAsHex(resource.getInputStream());
                }
            } catch (IOException e) {
                log.error("Failed to calculate content hash for: " + resourcePath, e);
            }
            return String.valueOf(System.currentTimeMillis());
        }
    }
    
    // 最佳实践2：资源预加载
    @Component
    public class ResourcePreloader {
        
        @Autowired
        private CDNService cdnService;
        
        // 预加载关键资源
        public void preloadCriticalResources() {
            List<String> criticalResources = Arrays.asList(
                "/css/main.css",
                "/css/critical.css",
                "/js/app.js",
                "/js/vendor.js",
                "/images/logo.png",
                "/images/hero-bg.jpg"
            );
            
            // 预热CDN缓存
            cdnService.preloadResources(criticalResources);
            
            log.info("Critical resources preloaded successfully");
        }
        
        // 智能预加载
        public void smartPreload() {
            // 分析用户访问模式
            Map<String, Integer> accessPatterns = analyzeAccessPatterns();
            
            // 识别高频访问资源
            List<String> highFrequencyResources = accessPatterns.entrySet().stream()
                    .filter(entry -> entry.getValue() > 1000) // 访问次数超过1000
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList());
            
            // 预加载高频资源
            if (!highFrequencyResources.isEmpty()) {
                cdnService.preloadResources(highFrequencyResources);
            }
        }
        
        private Map<String, Integer> analyzeAccessPatterns() {
            // 分析访问日志，识别高频资源
            return new HashMap<>();
        }
    }
    
    // 最佳实践3：自适应压缩
    @Component
    public class AdaptiveCompressionService {
        
        // 根据客户端能力和网络状况选择压缩策略
        public CompressionStrategy selectCompressionStrategy(HttpServletRequest request) {
            String userAgent = request.getHeader("User-Agent");
            String acceptEncoding = request.getHeader("Accept-Encoding");
            
            // 检测客户端能力
            boolean supportsGzip = acceptEncoding != null && acceptEncoding.contains("gzip");
            boolean supportsBrotli = acceptEncoding != null && acceptEncoding.contains("br");
            
            // 检测网络状况（简化实现）
            NetworkQuality networkQuality = detectNetworkQuality(request);
            
            // 选择最优压缩策略
            if (networkQuality == NetworkQuality.POOR) {
                // 网络质量差，使用高压缩比
                return supportsBrotli ? CompressionStrategy.BROTLI_HIGH : 
                       supportsGzip ? CompressionStrategy.GZIP_HIGH : 
                       CompressionStrategy.NONE;
            } else if (networkQuality == NetworkQuality.GOOD) {
                // 网络质量好，使用平衡压缩
                return supportsBrotli ? CompressionStrategy.BROTLI_BALANCED : 
                       supportsGzip ? CompressionStrategy.GZIP_BALANCED : 
                       CompressionStrategy.NONE;
            } else {
                // 网络质量优秀，使用快速压缩
                return supportsBrotli ? CompressionStrategy.BROTLI_FAST : 
                       supportsGzip ? CompressionStrategy.GZIP_FAST : 
                       CompressionStrategy.NONE;
            }
        }
        
        private NetworkQuality detectNetworkQuality(HttpServletRequest request) {
            // 简化的网络质量检测逻辑
            // 实际应用中可以通过更复杂的算法判断
            return NetworkQuality.GOOD;
        }
    }
    
    // 最佳实践4：渐进式加载
    @Component
    public class ProgressiveLoadingService {
        
        // 生成渐进式加载配置
        public ProgressiveLoadingConfig generateLoadingConfig(String resourcePath) {
            ProgressiveLoadingConfig config = new ProgressiveLoadingConfig();
            
            if (resourcePath.endsWith(".jpg") || resourcePath.endsWith(".jpeg")) {
                // 图片渐进式加载
                config.setLoadingStrategy(LoadingStrategy.PROGRESSIVE);
                config.setPlaceholder("/images/placeholder.jpg");
                config.setLowQualityPreview("/images/preview/" + resourcePath);
                config.setHighQualityResource(resourcePath);
            } else if (resourcePath.endsWith(".css")) {
                // CSS关键路径优化
                config.setLoadingStrategy(LoadingStrategy.CRITICAL);
                config.setCriticalCss("/css/critical.css");
                config.setNonCriticalCss(resourcePath);
            } else if (resourcePath.endsWith(".js")) {
                // JS异步加载
                config.setLoadingStrategy(LoadingStrategy.ASYNC);
                config.setAsyncLoading(true);
                config.setDeferLoading(true);
            }
            
            return config;
        }
    }
    
    // 最佳实践5：缓存分层
    @Configuration
    public class MultiLevelCacheConfig {
        
        // 浏览器缓存配置
        @Bean
        public CacheControl browserCacheControl() {
            return CacheControl.maxAge(365, TimeUnit.DAYS)
                    .cachePublic()
                    .immutable();
        }
        
        // CDN缓存配置
        @Bean
        public CacheControl cdnCacheControl() {
            return CacheControl.maxAge(30, TimeUnit.DAYS)
                    .cachePublic()
                    .sMaxAge(86400); // CDN缓存24小时
        }
        
        // Nginx缓存配置
        @Bean
        public CacheControl nginxCacheControl() {
            return CacheControl.maxAge(1, TimeUnit.HOURS)
                    .cachePublic()
                    .mustRevalidate();
        }
        
        // 应用缓存配置
        @Bean
        public CacheControl applicationCacheControl() {
            return CacheControl.maxAge(5, TimeUnit.MINUTES)
                    .cachePrivate()
                    .mustRevalidate();
        }
    }
}

性能优化案例分析

// 性能优化案例研究
@Component
public class PerformanceOptimizationCaseStudy {
    
    // 案例1：电商网站静态资源优化
    public void ecommerceOptimizationCase() {
        log.info("=== 电商网站静态资源优化案例 ===");
        
        // 问题描述：页面加载缓慢，静态资源占用大量带宽
        // 优化前性能指标：
        // - 页面加载时间：8.5秒
        // - 静态资源大小：2.3MB
        // - CDN命中率：65%
        // - 带宽成本：$5000/月
        
        // 优化策略实施：
        implementEcommerceOptimizations();
        
        // 优化后性能指标：
        // - 页面加载时间：2.1秒（降低75%）
        // - 静态资源大小：0.8MB（降低65%）
        // - CDN命中率：92%（提升27%）
        // - 带宽成本：$1800/月（降低64%）
        
        log.info("电商网站优化完成，性能提升显著");
    }
    
    private void implementEcommerceOptimizations() {
        // 1. 图片格式优化
        optimizeImageFormats();
        
        // 2. 资源合并与压缩
        mergeAndCompressResources();
        
        // 3. CDN节点优化
        optimizeCDNNodes();
        
        // 4. 缓存策略调整
        adjustCacheStrategies();
    }
    
    // 案例2：新闻门户静态资源优化
    public void newsPortalOptimizationCase() {
        log.info("=== 新闻门户静态资源优化案例 ===");
        
        // 问题描述：高并发访问下静态资源响应慢
        // 优化前性能指标：
        // - 并发用户数：10万
        // - 平均响应时间：1.2秒
        // - 服务器负载：85%
        // - 用户体验评分：3.2/5
        
        // 优化策略实施：
        implementNewsPortalOptimizations();
        
        // 优化后性能指标：
        // - 并发用户数：50万（提升400%）
        // - 平均响应时间：0.3秒（降低75%）
        // - 服务器负载：35%（降低59%）
        // - 用户体验评分：4.6/5（提升44%）
        
        log.info("新闻门户优化完成，并发处理能力大幅提升");
    }
    
    private void implementNewsPortalOptimizations() {
        // 1. 实施多级缓存架构
        implementMultiLevelCache();
        
        // 2. 优化资源加载顺序
        optimizeResourceLoadingOrder();
        
        // 3. 启用HTTP/2和Server Push
        enableHTTP2AndServerPush();
        
        // 4. 实施智能预加载
        implementSmartPreloading();
    }
    
    // 案例3：移动应用静态资源优化
    public void mobileAppOptimizationCase() {
        log.info("=== 移动应用静态资源优化案例 ===");
        
        // 问题描述：移动端加载缓慢，流量消耗大
        // 优化前性能指标：
        // - 首屏加载时间：6.8秒
        // - 数据流量消耗：5.2MB
        // - 用户流失率：35%
        // - 用户满意度：2.8/5
        
        // 优化策略实施：
        implementMobileOptimizations();
        
        // 优化后性能指标：
        // - 首屏加载时间：1.5秒（降低78%）
        // - 数据流量消耗：1.8MB（降低65%）
        // - 用户流失率：12%（降低66%）
        // - 用户满意度：4.3/5（提升54%）
        
        log.info("移动应用优化完成，移动端体验显著改善");
    }
    
    private void implementMobileOptimizations() {
        // 1. 响应式图片优化
        optimizeResponsiveImages();
        
        // 2. 自适应压缩策略
        implementAdaptiveCompression();
        
        // 3. 离线缓存策略
        implementOfflineCache();
        
        // 4. 弱网优化
        optimizeForWeakNetwork();
    }
    
    // 辅助优化方法
    private void optimizeImageFormats() {
        log.info("Optimizing image formats...");
        // 实现图片格式优化逻辑
    }
    
    private void mergeAndCompressResources() {
        log.info("Merging and compressing resources...");
        // 实现资源合并压缩逻辑
    }
    
    private void optimizeCDNNodes() {
        log.info("Optimizing CDN nodes...");
        // 实现CDN节点优化逻辑
    }
    
    private void adjustCacheStrategies() {
        log.info("Adjusting cache strategies...");
        // 实现缓存策略调整逻辑
    }
    
    private void implementMultiLevelCache() {
        log.info("Implementing multi-level cache...");
        // 实现多级缓存逻辑
    }
    
    private void optimizeResourceLoadingOrder() {
        log.info("Optimizing resource loading order...");
        // 实现资源加载顺序优化逻辑
    }
    
    private void enableHTTP2AndServerPush() {
        log.info("Enabling HTTP/2 and Server Push...");
        // 实现HTTP/2和Server Push逻辑
    }
    
    private void implementSmartPreloading() {
        log.info("Implementing smart preloading...");
        // 实现智能预加载逻辑
    }
    
    private void optimizeResponsiveImages() {
        log.info("Optimizing responsive images...");
        // 实现响应式图片优化逻辑
    }
    
    private void implementAdaptiveCompression() {
        log.info("Implementing adaptive compression...");
        // 实现自适应压缩逻辑
    }
    
    private void implementOfflineCache() {
        log.info("Implementing offline cache...");
        // 实现离线缓存逻辑
    }
    
    private void optimizeForWeakNetwork() {
        log.info("Optimizing for weak network...");
        // 实现弱网优化逻辑
    }
}