Spring框架中的策略模式实践：动态切换与同步Redis与本地内存解决方案

站长

2024年07月16日 02:44 · 阅读数 28

开头：

在开发中，内存数据管理是提高应用性能和用户体验的关键环节。尤其是在面对高并发和大数据量处理的场景下，合理利用内存资源，确保数据处理的高效和稳定，成为了开发者不得不解决的问题。Spring框架作为Java领域��泛使用的应用框架，为开发者提供了强大的工具和丰富的生态来构建应用。本文将重点介绍如何在Spring框架中利用策略模式来动态切换和同步Redis与本地内存，以达到优化性能和资源利用的目的

正文

JVM本地内存（也称为堆外内存）和使用Redis内存是两种不同的内存管理方式，它们在应用程序中扮演着不同的角色。

JVM本地内存（堆外内存）：

JVM本地内存是指不由Java虚拟机（JVM）的垃圾回收器管理的内存。这部分内存位于JVM堆内存之外，常用于NIO（New I/O）缓冲区、DirectByteBuffer、内存映射文件等。
JVM本地内存的使用可以避免JVM堆内存的频繁垃圾回收操作，有助于提高性能，特别是在处理大量I/O操作时。
管理JVM本地内存需要开发者手动分配和释放，容易产生内存泄漏。

使用Redis内存：

Redis是一个基于内存的键值存储数据库，它的数据存储在服务器的内存中，与JVM内存分离。
使用Redis可以实现数据的持久化存储，支持数据的备份和恢复，同时也提供了丰富的数据结构和原子操作。
Redis内存主要用于数据缓存、会话存储、消息队列等，可以减轻后端数据库的压力，提高数据访问速度。
Redis运行在独立的进程中，它的内存管理由Redis自身负责，与JVM无关。

关系和不同点：

关系：在分布式系统中，JVM本地内存和Redis内存可以共同工作，提高系统的性能和伸缩性。例如，一个Java应用可能使用JVM本地内存来处理临时数据，同时使用Redis作为分布式缓存来存储共享数据。
不同点：
- 管理方式：JVM本地内存由Java应用管理，而Redis内存由Redis服务器管理。
- 位置：JVM本地内存位于应用程序的进程空间内，Redis内存位于远程服务器上。
- 用途：JVM本地内存通常用于提高应用程序的性能，而Redis内存用于数据共享、缓存和持久化。
- 持久性：JVM本地内存通常不用于持久化数据，而Redis提供数据持久化功能。
- 分布式特性：Redis天然支持分布式环境，而JVM本地内存通常局限于单个JVM进程。

在实际应用中，根据不同的业务需求和系统架构，开发者可以选择合适的内存管理策略，或者将它们结合起来使用，以达到最佳的性能和可扩展性。

结合

创建一个更通用的内存策略接口，并提供两个策略实现类:一个用于Redisson操作的Redis策略，另一个用于本地内存操作。同时，将保持接口的开放性，以便未来可以轻松添加更多策略。

首先，定义一个内存操作的接口：

public interface CacheStrategy {
    <T> void put(String key, T value);
    <T> T get(String key, Class<T> type);
    void remove(String key);
}

定义一个CacheMessagePublisher接口和一个CacheMessage类来封装缓存更新消息的内容：

public interface CacheMessagePublisher {
    void publish(CacheMessage message);
}

public class CacheMessage implements Serializable {
    private String key;
    private Object value;
    private CacheOperation operation;

    public CacheMessage(String key, Object value, CacheOperation operation) {
        this.key = key;
        this.value = value;
        this.operation = operation;
   }

    // Getter and setter methods...

    public enum CacheOperation {
        PUT,
        REMOVE
    }
}

接下来，我们实现CacheMessagePublisher接口，用于发布缓存更新消息到Redis：

@Service
public class RedisCacheMessagePublisher implements CacheMessagePublisher {

    private final RedissonClient redissonClient;
    private final String cacheSyncTopic = "cacheSyncTopic";

    @Autowired
    public RedisCacheMessagePublisher(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public void publish(CacheMessage message) {
        RTopic topic = redissonClient.getTopic(cacheSyncTopic);
        topic.publish(message);
    }
}

然后，实现一个基于Redisson的Redis策略类：

@Service
public class RedissonCacheStrategy implements CacheStrategy {

    private final RedissonClient redissonClient;
	@Autowired
    private CacheMessagePublisher cacheMessagePublisher;
    @Autowired
    public RedissonCacheStrategy(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public <T> void put(String key, T value) {
        RBucket<T> bucket = redissonClient.getBucket(key);
        bucket.set(value);
        // 可以在这里添加同步到其他存储的逻辑
        // 发布消息到Redis，通知其他缓存实例进行更新  
     cacheMessagePublisher.publish(new CacheMessage(key, value, CacheMessage.CacheOperation.PUT));
    }

    @Override
    public <T> T get(String key, Class<T> type) {
        RBucket<T> bucket = redissonClient.getBucket(key);
        return bucket.get();
    }

    @Override
    public void remove(String key) {
        RBucket<Object> bucket = redissonClient.getBucket(key);
        bucket.delete();
        // 可以在这里添加同步到其他存储的逻辑
        // 发布消息到Redis，通知其他缓存实例进行更新  
       cacheMessagePublisher.publish(new CacheMessage(key, null, CacheMessage.CacheOperation.REMOVE));
    }
	
	
	// 新增方法，用于更新Redis缓存但不发布同步消息
    public <T> void putWithoutPublishing(String key, T value) {
        RBucket<T> bucket = redissonClient.getBucket(key);
        bucket.set(value);
    }

    // 新增方法，用于从Redis缓存中移除数据但不发布同步消息
    public void removeWithoutPublishing(String key) {
        RBucket<Object> bucket = redissonClient.getBucket(key);
        bucket.delete();
    }
}

接下来，实现本地内存策略类：

@Service
public class LocalCacheStrategy implements CacheStrategy {

    private static final ConcurrentMap<String, Object> localCache = new ConcurrentHashMap<>();
 @Autowired
    private CacheMessagePublisher cacheMessagePublisher;
    @Override
    public <T> void put(String key, T value) {
        localCache.put(key, value);
        // 可以在这里添加同步到其他存储的逻辑
		cacheMessagePublisher.publish(new CacheMessage(key, value, CacheMessage.CacheOperation.PUT));
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T get(String key, Class<T> type) {
        return (T) localCache.get(key);
    }

    @Override
    public void remove(String key) {
        localCache.remove(key);
        // 可以在这里添加同步到其他存储的逻辑
	cacheMessagePublisher.publish(new CacheMessage(key, null, CacheMessage.CacheOperation.REMOVE));
    }
	    // 新增方法，用于更新本地缓存但不发布同步消息
    public <T> void putWithoutPublishing(String key, T value) {
        localCache.put(key, value);
    }

    // 新增方法，用于从本地缓存中移除数据但不发布同步消息
    public void removeWithoutPublishing(String key) {
        localCache.remove(key);
    }
}

实现一个消息监听器来订阅Redis中的缓存同步消息，并更新相应的缓存：

@Service
public class CacheMessageSubscriber {

    private final LocalCacheStrategy localCacheStrategy;
    private final RedissonCacheStrategy redissonCacheStrategy;
    private final RedissonClient redissonClient;
    private final String cacheSyncTopic = "cacheSyncTopic";

    @Autowired
    public CacheMessageSubscriber(LocalCacheStrategy localCacheStrategy,
                                  RedissonCacheStrategy redissonCacheStrategy,
                                  RedissonClient redissonClient) {
        this.localCacheStrategy = localCacheStrategy;
        this.redissonCacheStrategy = redissonCacheStrategy;
        this.redissonClient = redissonClient;
    }

    @PostConstruct
    public void subscribeToCacheSyncTopic() {
        RTopic topic = redissonClient.getTopic(cacheSyncTopic);
        topic.addListener(CacheMessage.class, (channel, message) -> {
            switch (message.getOperation()) {
                case PUT:
                    // Update the other cache without publishing the event again
                    if (message.getSource().equals("local")) {
                        redissonCacheStrategy.putWithoutPublishing(message.getKey(), message.getValue());
                    } else {
                        localCacheStrategy.putWithoutPublishing(message.getKey(), message.getValue());
                    }
                    break;
                case REMOVE:
                    // Remove from the other cache without publishing the event again
                    if (message.getSource().equals("local")) {
                        redissonCacheStrategy.removeWithoutPublishing(message.getKey());
                    } else {
                        localCacheStrategy.removeWithoutPublishing(message.getKey());
                    }
                    break;
            }
        });
    }
}

现在，创建一个上下文类来管理策略，并提供统一的接口给客户端代码：

@Service
public class CacheContext {

    private CacheStrategy cacheStrategy;

    public void setCacheStrategy(CacheStrategy cacheStrategy) {
        this.cacheStrategy = cacheStrategy;
    }

    public <T> void put(String key, T value) {
        cacheStrategy.put(key, value);
    }

    public <T> T get(String key, Class<T> type) {
        return cacheStrategy.get(key, type);
    }

    public void remove(String key) {
        cacheStrategy.remove(key);
    }
}

最后，可以在客户端代码中根据条件设置所需的策略，并进行操作：

@RestController
public class CacheController {

    private final CacheContext cacheContext;
    private final RedissonCacheStrategy redissonCacheStrategy;
    private final LocalCacheStrategy localCacheStrategy;

    @Autowired
    public CacheController(CacheContext cacheContext, RedissonCacheStrategy redissonCacheStrategy, LocalCacheStrategy localCacheStrategy) {
        this.cacheContext = cacheContext;
        this.redissonCacheStrategy = redissonCacheStrategy;
        this.localCacheStrategy = localCacheStrategy;
    }

    @PostMapping("/cache/{key}")
    public ResponseEntity<?> putData(@PathVariable String key, @RequestBody Object value, @RequestParam String strategy) {
        switchStrategy(strategy);
        cacheContext.put(key, value);
        return ResponseEntity.ok().build();
    }

    @GetMapping("/cache/{key}")
    public ResponseEntity<?> getData(@PathVariable String key, @RequestParam String strategy) {
        switchStrategy(strategy);
        Object value = cacheContext.get(key, Object.class);
        return ResponseEntity.ok(value);
    }

    @DeleteMapping("/cache/{key}")
    public ResponseEntity<?> removeData(@PathVariable String key, @RequestParam String strategy) {
        switchStrategy(strategy);
        cacheContext.remove(key);
        return ResponseEntity.ok().build();
    }

    private void switchStrategy(String strategy) {
        if ("redisson".equalsIgnoreCase(strategy)) {
            cacheContext.setCacheStrategy(redissonCacheStrategy);
        } else if ("local".equalsIgnoreCase(strategy)) {
            cacheContext.setCacheStrategy(localCacheStrategy);
        } else {
            throw new IllegalArgumentException("Unknown cache strategy");
        }
    }
}

用了CacheMessage中的一个额外字段source来标识消息来源，这样我们可以避免循环同步。当本地缓存更新时，它会发布一个带有source: local的消息；而Redis缓存更新时，它会发布一个带有source: redis的消息。消息监听器会根据消息来源更新另一个缓存，但不会再次发布同步消息。

请注意，上述代码中的putWithoutPublishing和removeWithoutPublishing方法需要在RedissonCacheStrategy和LocalCacheStrategy中实现，它们与正常的put和remove方法类似，但不会发布同步消息。

在这个示例中，通过CacheController类提供的REST API来进行数据的CRUD操作，并且可以通过请求参数strategy来选择使用Redisson内存还是本地内存策略。CacheContext类用于在运行时切换不同的策略。这个设计允许将来轻松添加新的策略实现。

这个示例是一个简化的版本，仅用于演示如何在Spring中实现策略模式以及数据同步。在生产环境中，可能需要考虑更多的因素，如数据同步的一致性、错误处理、性能优化等。此外，同步数据到其他存储的逻辑应根据具体的业务需求和系统架构来设计。

结尾：

通过本文的详细介绍，了解了在Spring框架中实现动态内存策略切换的方法和步骤，以及如何在不同内存策略之间进行数据同步。首先探讨了内存管理的重要性和内存策略模式的概念，然后逐步展示了策略模式的实现，包括定义内存操作接口、实现具体的Redis和本地内存策略类，以及创建上下文管理器来动态切换策略。最后，通过REST API的实例演示了如何在实际应用中使用这些策略。本文的实践方案不仅可以提高数据处理的效率和应用的可扩展性，还为未来引入新的内存策略提供了灵活性和可扩展性。希望这些内容能为在构建高性能Spring应用时提供有价值的参考。

转载自:https://juejin.cn/post/7387320448167673894