相对于本地应用缓存，分布式缓存具有如下特性:
   
1) 高性能
    当传统数据库面临大规模数据访问时，磁盘 I/O 往往成为性能瓶颈，从而导致过高的响应延迟。
    分布式缓存将高速内存作为数据对象的存储介质，数据以 key/value 形式存储。

2) 动态扩展性
    支持弹性扩展，通过动态增加或减少节点应对变化的数据访问负载，提供可预测的性能与扩展性；
    同时，最大限度地提高资源利用率；

3) 高可用性
    高可用性包含数据可用性与服务可用性两方面，故障的自动发现，自动转义。
    确保不会因服务器故障而导致缓存服务中断或数据丢失。

4) 易用性
    提供单一的数据与管理视图；
    API 接口简单，且与拓扑结构无关；
    动态扩展或失效恢复时无需人工配置;
    自动选取备份节点；
    多数缓存系统提供了图形化的管理控制台，便于统一维护。

分布式缓存的典型应用场景可分为以下几类：

1) 页面缓存
    用来缓存 Web 页面的内容片段，包括 HTML、CSS 和图片等，多应用于社交网站等。

2) 应用对象缓存
    缓存系统作为 ORM 框架的二级缓存对外提供服务，目的是减轻数据库的负载压力，加速应用访问。

3) 状态缓存
    缓存包括 Session 会话状态及应用横向扩展时的状态数据等。
    这类数据一般是难以恢复的，对可用性要求较高，多应用于高可用集群。

4) 并行处理
    通常涉及大量中间计算结果需要共享。

5) 事件处理
    分布式缓存提供了针对事件流的连续查询 (continuous query) 处理技术，满足实时性需求。

6) 极限事务处理
    分布式缓存为事务型应用提供高吞吐率、低延时的解决方案，支持高并发事务请求处理。
    多应用于铁路、金融服务和电信等领域。

通过在应用服务与 DB 中间引入缓存层，我们可以得到如下三个好处：
（1）读取速度得到提升。
（2）系统扩展能力得到大幅增强。我们可以通过加缓存，来让系统的承载能力提升。
（3）总成本下降，单台缓存即可承担原来的多台DB的请求量，大大节省了机器成本。

✅ Memcached 是一个高性能，分布式内存对象缓存系统。
   通过在内存里维护一个统一的巨大的 Hash 表，它能够用来存储各种格式的数据，包括图像、视频、文件以及数据库检索的结果等。
   简单的说就是：将数据缓存到内存中，然后从内存中读取，从而大大提高读取速度。

✅ Memcached 特性
1. 使用物理内存作为缓存区，可独立运行在服务器上。
   每个进程最大 2G，如果想缓存更多的数据，可以开辟更多的 Memcached 进程（不同端口）
   或者使用分布式 Memcached 进行缓存，将数据缓存到不同的物理机或者虚拟机上。

2. 使用 key-value 的方式来存储数据。
   这是一种单索引的结构化数据组织形式，可使数据项查询时间复杂度为 O(1)。

3. 协议简单，基于文本行的协议。
   直接通过 telnet 在 Memcached 服务器上可进行存取数据操作。简单、方便多种缓存参考此协议。

4. 基于 libevent 高性能通信。
   Libevent 是一套利用 C 开发的程序库，它将 BSD 系统的 kqueue，Linux 系统的 epoll 等事件处理功能封装成一个接口，
   与传统的 select 相比，提高了性能。

5. 分布式能力取决于 Memcached 客户端，服务器之间互不通信。
   各个 Memcached 服务器之间互不通信，各自独立存取数据，不共享任何信息。
   服务器并不具有分布式功能，分布式部署取决于 Memcached 客户端。

6. 采用 LRU 缓存淘汰策略。
   在 Memcached 内存储数据项时，可以指定它在缓存的失效时间，默认为永久。
   当 Memcached 服务器用完分配的内时，失效的数据被首先替换，然后也是最近未使用的数据。
   在 LRU 中，Memcached 使用的是一种 Lazy Expiration 策略，自己不会监控存入的 key/vlue 对是否过期，
   而是在获取 key 值时查看记录的时间戳，检查 key/value 对空间是否过期，这样可减轻服务器的负载。

7. 内置了一套高效的内存管理算法。这套内存管理效率很高，而且不会造成内存碎片，但是它最大的缺点就是会导致空间浪费。
   当内存满后，通过 LRU 算法自动删除不使用的缓存。

8. 不支持持久化。Memcached 没有考虑数据的容灾问题，重启服务，所有数据会丢失。

✅ Redis 是一个开源（BSD 许可）数据库。
   基于内存的，支持网络、可基于内存、分布式、可选持久性的键值对 (Key-Value) 存储数据库。
   提供多种语言的 API。
   可以用作数据库、缓存和消息中间件。

✅ Redis 支持多种数据类型 - string、Hash、list、set、sorted set。
   提供两种持久化方式 - RDB 和 AOF。
   通过 Redis cluster 提供集群模式。

✅ Redis的优势：
1. 性能极高
   Redis 能读的速度是110000次/s，写的速度是81000次/s

2. 丰富的数据类型
   Redis 支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。

3. 原子
   Redis 的所有操作都是原子性的，同时 Redis 还支持对几个操作合并后的原子性执行。（事务）

4. 丰富的特性
   Redis 还支持 publish/subscribe、通知、key 过期等特性。

如上图所示，系统会自动根据调用的方法缓存请求的数据。
当再次调用该方法时，系统会首先从缓存中查找是否有相应的数据，
If 命中缓存，则从缓存中读取数据并返回；
If 没有命中，则请求数据库查询相应的数据并再次缓存。

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
 
    /**
     * 采用RedisCacheManager作为缓存管理器
     * 为了处理高可用Redis，可以使用RedisSentinelConfiguration来支持Redis Sentinel
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory).build();
        return redisCacheManager;
    }
 
    /**
     * 自定义生成 key 的规则
     */
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object...objects) {
                // 格式化缓存key字符串
                StringBuilder stringBuilder = new StringBuilder();
                // 追加类名
               stringBuilder.append(o.getClass().getName());
                // 追加方法名
               stringBuilder.append(method.getName());
                // 遍历参数并且追加
                for (Object obj :objects) {
                   stringBuilder.append(obj.toString());
                }
               System.out.println("调用Redis缓存Key: " + stringBuilder.toString());
                return stringBuilder.toString();
            }
        };
    }
}

@Repository
public class UserRepository {
 
    / **
     * @Cacheable 应用到读取数据的方法上，先从缓存中读取，如果没有，再从DB获取数据，然后把数据添加到缓存中
     *            unless 表示条件表达式成立的话不放入缓存
     * @param username
     * @return
     */
    @Cacheable(value = "user")
    public User getUserByName(String username) {
        User user = new User();
       user.setName(username);
        user.setAge(30);
       user.setPassword("123456");
       System.out.println("user info from database");
        return user;
    }
}

@Test
public void testGetUserByName() {
    User user = userRepository.getUserByName("siona");
   System.out.println("name: "+ user.getName()+",age:"+user.getAge());
 
    user = userRepository.getUserByName("siona");
   System.out.println("name: "+ user.getName()+",age:"+user.getAge());
}

原理：
    在保存数据的时候，会通过 Hash 散列函数将它映射为一个位数组中的 K 个点，同时把他的值置为 1。
    这样当用户再次来查询 A 时，而 A 在布隆过滤器值为 0，直接返回，就不会产生击穿请求打到 DB 了。

1️⃣ 删除和修改数据
情况 1：先删除缓存，再更新数据库。
    潜在的问题：数据库更新失败了，get 请求进来发现没缓存则请求数据库，导致缓存又刷入了旧的值。

情况 2：先更新数据库，再删除缓存。
    潜在的问题：缓存删除失败，get 请求进来缓存命中，导致读到的是旧值。

2️⃣ 先删除缓存再更新数据库
假设有 2 个线程 A 和 B。
A 删除缓存之后，由于网络延迟，在更新数据库之前，B 来访问了，发现缓存未命中，则去请求数据库然后把旧值刷入了缓存，
这时候姗姗来迟的 A，才把最新数据刷入数据库，导致了数据的不一致性。

解决方案：
针对多线程的场景，可以采用延迟双删的解决方案，我们可以在 A 更新完数据库之后，线程 A 先休眠一段时间，再删除缓存。
需要注意的是：具体休眠的时间，需要评估自己的项目的读数据业务逻辑的耗时。
            这么做的目的，就是确保读请求结束，写请求可以删除读请求造成的缓存脏数据。
            当然这种策略还要考虑 redis 和数据库主从同步的耗时。

3️⃣ 先更新数据库再删除缓存
这种场景潜在的风险就是更新完数据库，删缓存之前，会有部分并发请求读到旧值，
这种情况对业务影响较小，可以通过重试机制，保证缓存能得到删除。