Spring单例Bean的生命周期与内存管理策略

// Spring Boot主应用类
@SpringBootApplication
@EnableCaching // 启用Spring缓存抽象
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
@EnableCaching
public class CachingConfig {

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES) // 设置缓存项在写入后10分钟过期
                .maximumSize(1000)); // 设置缓存最大容量为1000个条目
        return cacheManager;
    }
}

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

@Service
public class DataService {

    /**
     * 从缓存中获取数据，如果不存在则调用方法加载并放入缓存。
     * 缓存名称为"myDataCache"，key为方法参数id。
     * unless条件表示当返回结果为null时不缓存。
     */
    @Cacheable(value = "myDataCache", key = "#id", unless = "#result == null")
    public MyComplexObject getComplexData(String id) {
        System.out.println("Loading complex data for id: " + id + " from source...");
        // 模拟从数据库、外部API或其他耗时操作中加载数据
        return new MyComplexObject(id, "Some large data payload for " + id);
    }

    /**
     * 清除指定key的缓存项。
     */
    @CacheEvict(value = "myDataCache", key = "#id")
    public void evictComplexData(String id) {
        System.out.println("Evicting complex data for id: " + id + " from cache.");
    }

    // 假设MyComplexObject是一个占用内存较多的数据结构
    static class MyComplexObject {
        private String id;
        private String data; // 模拟大量数据

        public MyComplexObject(String id, String data) {
            this.id = id;
            this.data = data;
        }
        // getters, setters, etc.
    }
}

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class CustomDataCacheManager {

    private final Cache<String, MyComplexObject> dataCache;

    public CustomDataCacheManager() {
        // 构建一个Caffeine缓存实例
        this.dataCache = Caffeine.newBuilder()
                .expireAfterWrite(15, TimeUnit.MINUTES) // 写入后15分钟过期
                .maximumSize(500) // 最大缓存条目数
                .build();
    }

    public MyComplexObject getOrLoadData(String key) {
        // 使用get方法，如果key不存在，则通过lambda表达式加载数据并放入缓存
        return dataCache.get(key, k -> {
            System.out.println("Loading data for key: " + k + " directly from source...");
            // 模拟数据加载
            return new MyComplexObject(k, "More large data for " + k);
        });
    }

    public void invalidateData(String key) {
        dataCache.invalidate(key); // 手动使某个key的缓存失效
        System.out.println("Invalidating data for key: " + key);
    }

    public void clearAllCache() {
        dataCache.invalidateAll(); // 清除所有缓存
        System.out.println("All cache entries invalidated.");
    }

    static class MyComplexObject {
        private String id;
        private String data;

        public MyComplexObject(String id, String data) {
            this.id = id;
            this.data = data;
        }
        // getters, setters, etc.
    }
}