spring cloud微服务架构开发中，服务间通过feign调用，用的很爽，但有的时候一次业务逻辑操作需要调同一个接口很多次，接口返回的数据是一样的，多次rpc调用，网络开销很大，影响性能。

        如果每次调用返回的数据是固定的，何不把它缓存起来呢？

        这里我们直接用spring的缓存注解@Cacheable来做本地缓存。

       一、定义一个缓存类：

@Component
public class ShopCacheReader {

  @Autowired
  private FShopService fShopService;
    
  @Cacheable(value = "CACHE_SHOP",key = "#shopId", unless = "#result == null")
  public ShopDTO getShopByShopId(String shopId){
      if(StringUtils.isBlank(shopId)){
          return null;
      }
      try {
          ShopDTO shop = fShopService.getShopByShopId(shopId);
          return shop;
      }catch (Exception e){
          throw e;
      }
  }
}

在需要被缓存的方法上加@Cacheable注解，这样该方法的返回值会自动被缓存，第二次的调用的时候就会走缓存，而不会每次都调用feign接口。

二、创建一个配置类：

@EnableCaching
@Configuration
@Slf4j
public class LocalCacheConfigration {
    private static final int DEFAULT_TTL = 10;
    private static final int DEFAULT_MAXSIZE = 50000;

    @Bean
    @Primary
    public CacheManager caffeineCacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        List<CaffeineCache> caches = new ArrayList<>();
        for (Caches c : Caches.values()) {
            caches.add(new CaffeineCache(c.name(),
                    Caffeine.newBuilder()
                            .recordStats()
                            .expireAfterWrite(c.getTtl(), TimeUnit.SECONDS)
                            .maximumSize(c.getMaxSize())
                            .build())
            );
        }
        cacheManager.setCaches(caches);
        log.info("初始化本地缓存");
        return cacheManager;
    }

    public enum Caches {

        CACHE_SHOP(15, 50),
        CACHE_ORDER(600,1000),
        CACHE_COMPANY(600,1000);

        private int ttl = DEFAULT_TTL;
        private int maxSize = DEFAULT_MAXSIZE;

        Caches() {
        }

        Caches(int ttl) {
            this.ttl = ttl;
        }

        Caches(int ttl, int maxSize) {
            this.ttl = ttl;
            this.maxSize = maxSize;
        }

        public int getMaxSize() {
            return maxSize;
        }

        public int getTtl() {
            return ttl;
        }
    }
}

这里使用CaffeineCache缓存框架，因为性能好，可自行学习，直接引用maven依赖就可以了。

<dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>2.3.5</version>
        </dependency>

CacheManager便于管理我们定义好的缓存，可以指定缓存的失效时间，以及最大容量。

不是所有的场景都可以用本地缓存，我们需要考虑服务器的内存，还有数据量，如果缓存的数据量太大，就不适合用本地缓存，会占用服务器内存，慎重考虑。