Redis在微服务架构中的应用

1.概述

Redis可以广泛用于微服务架构。它可能是您应用程序以多种不同方式利用的少数流行软件解决方案之一。根据要求，它可以充当主数据库，缓存，消息代理。虽然它也是一个键/值存储，但我们可以将它用作微服务架构中的配置服务器或发现服务器。虽然它通常被定义为内存中的数据结构，但我们也可以在持久模式下运行它。 今天，我将向您展示一些使用Redis与Spring Boot和Spring Cloud框架之上构建的微服务的示例。这些应用程序将使用Redis Pub / Sub异步通信，使用Redis作为缓存或主数据库，最后使用Redis作为配置服务器。这是说明架构的图片。

2.Redis作为配置服务器

如果已经使用Spring Cloud构建了微服务，您可能已经接触过Spring Cloud Config。它负责为微服务提供分布式配置模式。不幸的是，Spring Cloud Config不支持Redis作为属性源后端存储库。这就是我决定分离Spring Cloud Config项目并实现此功能的原因。我希望我的实现很快将被包含在正式的Spring Cloud版本中，但是现在你可以使用我的fork repo来运行它。它可以在我的GitHub帐户piomin / spring-cloud-config上找到。如何使用它？非常简单。让我们来看看。 目前SNAPSHOT版本的Spring Boot是2.2.0.BUILD-SNAPSHOT，与Spring Cloud Config相同。在构建Spring Cloud Config Server时，我们只需要包含这两个依赖项，如下所示。

1. <parent>

2. <groupId>org.springframework.boot</groupId>

3. <artifactId>spring-boot-starter-parent</artifactId>

4. <version>2.2.0.BUILD-SNAPSHOT</version>

5. </parent>

6. <artifactId>config-service</artifactId>

7. <groupId>pl.piomin.services</groupId>

8. <version>1.0-SNAPSHOT</version>

9. <dependencies>

10. <dependency>

11. <groupId>org.springframework.cloud</groupId>

12. <artifactId>spring-cloud-config-server</artifactId>

13. <version>2.2.0.BUILD-SNAPSHOT</version>

14. </dependency>

15. </dependencies>

默认情况下，Spring Cloud Config Server使用Git存储库后端。我们需要激活redis配置文件以强制使用Redis作为后端。如果您的Redis实例侦听的是另一个地址localhost:6379，则需要使用spring.redis.*属性覆盖自动配置的连接设置。这是我们的bootstrap.yml文件。

1. spring:

2. application:

3. name: config-service

4. profiles:

5. active: redis

6. redis:

7. host: 192.168.99.100

应用程序主类应注释@EnableConfigServer。

1. @SpringBootApplication

2. @EnableConfigServer

3. public class ConfigApplication {

4. public static void main(String[] args) {

5. new SpringApplicationBuilder(ConfigApplication.class).run(args);

6. }

7. }

在运行应用程序之前，我们需要启动Redis实例。这是将其作为Docker容器运行并在端口6379上公开的命令。

1. $ docker run -d --name redis -p 6379:6379 redis

每个应用程序的配置必须在密钥${spring.application.name}或${spring.application.name}-${spring.profiles.active[n]}。 我们必须使用与配置属性名称对应的键创建哈希。我们的示例应用程序driver-management使用三个配置属性：server.port用于设置HTTP侦听端口，spring.redis.host用于更改用作消息代理和数据库的默认Redis地址，以及sample.topic.name用于设置用于我们的微服务之间异步通信的主题名称。这是为driver-management使用RDBTools可视化而创建的Redis哈希的结构。该可视化相当于运行Redis CLI命令HGETALL，该命令返回散列中的所有字段和值。

1. >> HGETALL driver-management

2. {

3. "server.port": "8100",

4. "sample.topic.name": "trips",

5. "spring.redis.host": "192.168.99.100"

6. }

在Redis中设置密钥和值并使用活动redis配置文件运行Spring Cloud Config Server之后，我们需要在客户端启用分布式配置功能。要做到这一点，我们只需要包含对每个微服务的spring-cloud-starter-config依赖性pom.xml。

1. <dependency>

2. <groupId>org.springframework.cloud</groupId>

3. <artifactId>spring-cloud-starter-config</artifactId>

4. </dependency>

我们使用最新的稳定版Spring Cloud。

1. <dependencyManagement>

2. <dependencies>

3. <dependency>

4. <groupId>org.springframework.cloud</groupId>

5. <artifactId>spring-cloud-dependencies</artifactId>

6. <version>Greenwich.SR1</version>

7. <type>pom</type>

8. <scope>import</scope>

9. </dependency>

10. </dependencies>

11. </dependencyManagement>

应用程序的名称是spring.application.name在启动时从属性中获取的，因此我们需要提供以下bootstrap.yml文件。

1. spring:

2. application:

3. name: driver-management

3.Redis作为消息代理

现在我们可以在基于微服务的体系结构 - 消息代理中继续使用Redis的第二个用例。我们将实现一个典型的异步系统，如下图所示。微服务trip-management在创建新行程和完成当前行程后向Redis Pub / Sub发送通知。通知由两者接收，driver-management并且passenger-management订阅特定频道.

我们的应用非常简单。我们只需要添加以下依赖项，以便提供REST API并与Redis Pub / Sub集成。

1. <dependency>

2. <groupId>org.springframework.boot</groupId>

3. <artifactId>spring-boot-starter-web</artifactId>

4. </dependency>

5. <dependency>

6. <groupId>org.springframework.boot</groupId>

7. <artifactId>spring-boot-starter-data-redis</artifactId>

8. </dependency>

我们应该用渠道名称和出版商注册bean。TripPublisher负责向目标主题发送消息。

1. @Configuration

2. public class TripConfiguration {

3. @Autowired

4. RedisTemplate<?, ?> redisTemplate;

5. @Bean

6. TripPublisher redisPublisher() {

7. return new TripPublisher(redisTemplate, topic());

8. }

9. @Bean

10. ChannelTopic topic() {

11. return new ChannelTopic("trips");

12. }

13. }

TripPublisher使用RedisTemplate将消息发送到的话题。在发送之前，使用将每个消息从对象转换为JSON字符串Jackson2JsonRedisSerializer。

1. public class TripPublisher {

2. private static final Logger LOGGER = LoggerFactory.getLogger(TripPublisher.class);

3. RedisTemplate<?, ?> redisTemplate;

4. ChannelTopic topic;

5. public TripPublisher(RedisTemplate<?, ?> redisTemplate, ChannelTopic topic) {

6. this.redisTemplate = redisTemplate;

7. this.redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Trip.class));

8. this.topic = topic;

9. }

10. public void publish(Trip trip) throws JsonProcessingException {

11. LOGGER.info("Sending: {}", trip);

12. redisTemplate.convertAndSend(topic.getTopic(), trip);

13. }

14. }

我们已经在发布者方面实现了逻辑。现在，我们可以继续在用户方面实施。我们有两个微服务driver-management，passenger-management它们监听trip-management微服务发送的通知。我们需要定义RedisMessageListenerContainerbean并设置消息监听器实现类。

1. @Configuration

2. public class DriverConfiguration {

3. @Autowired

4. RedisConnectionFactory redisConnectionFactory;

5. @Bean

6. RedisMessageListenerContainer container() {

7. RedisMessageListenerContainer container = new RedisMessageListenerContainer();

8. container.addMessageListener(messageListener(), topic());

9. container.setConnectionFactory(redisConnectionFactory);

10. return container;

11. }

12. @Bean

13. MessageListenerAdapter messageListener() {

14. return new MessageListenerAdapter(new DriverSubscriber());

15. }

16. @Bean

17. ChannelTopic topic() {

18. return new ChannelTopic("trips");

19. }

20. }

负责处理传入通知的类需要实现MessageListener接口。收到消息后，DriverSubscriber将其从JSON反序列化为对象并更改驱动程序状态。

1. @Service

2. public class DriverSubscriber implements MessageListener {

3. private final Logger LOGGER = LoggerFactory.getLogger(DriverSubscriber.class);

4. @Autowired

5. DriverRepository repository;

6. ObjectMapper mapper = new ObjectMapper();

7. @Override

8. public void onMessage(Message message, byte[] bytes) {

9. try {

10. Trip trip = mapper.readValue(message.getBody(), Trip.class);

11. LOGGER.info("Message received: {}", trip.toString());

12. Optional<Driver> optDriver = repository.findById(trip.getDriverId());

13. if (optDriver.isPresent()) {

14. Driver driver = optDriver.get();

15. if (trip.getStatus() == TripStatus.DONE)

16. driver.setStatus(DriverStatus.WAITING);

17. else

18. driver.setStatus(DriverStatus.BUSY);

19. repository.save(driver);

20. }

21. } catch (IOException e) {

22. LOGGER.error("Error reading message", e);

23. }

24. }

25. }

4.Redis作为主数据库

虽然使用Redis的主要目的是内存缓存或键/值存储，但它也可以充当应用程序的主数据库。在这种情况下，值得以持久模式运行Redis。

1. $ docker run -d --name redis -p 6379:6379 redis redis-server --appendonly yes

实体使用散列操作和mmap结构存储在Redis中。每个实体都需要一个哈希键和id。

1. @RedisHash("driver")

2. public class Driver {

3. @Id

4. private Long id;

5. private String name;

6. @GeoIndexed

7. private Point location;

8. private DriverStatus status;

9. // setters and getters ...

10. }

幸运的是，Spring Data Redis为Redis集成提供了众所周知的存储库模式。要启用它，我们应该使用注释配置或主类@EnableRedisRepositories。使用Spring存储库模式时，我们不必自己构建对Redis的任何查询。

1. @Configuration

2. @EnableRedisRepositories

3. public class DriverConfiguration {

4. // logic ...

5. }

使用Spring Data存储库，我们没有构建任何Redis查询，只是按照Spring Data约定命名方法。有关更多详细信息，请参阅我之前的文章Spring Data Redis简介。为了我们的示例目的，我们可以使用Spring Data中实现的默认方法。这是存储库接口的声明driver-management。

1. public interface DriverRepository extends CrudRepository<Driver, Long> {}

不要忘记通过使用注释主应用程序类或配置类来启用Spring Data存储库@EnableRedisRepositories。

1. @Configuration

2. @EnableRedisRepositories

3. public class DriverConfiguration {

4. ...

5. }

5.结论

正如我在前言中提到的，Redis在微服务架构中有各种用例。我刚刚介绍了如何与Spring Cloud和Spring Data一起使用它来提供配置服务器，消息代理和数据库。Redis通常被认为是一个缓存，但我希望在阅读完这篇文章后你会改变主意。示例应用程序源代码在GitHub上通常可用：https：//github.com/piomin/sample-redis-microservices.git。

原文链接：https://piotrminkowski.wordpress.com/2019/03/18/redis-in-microservices-architecture/

作者： PiotrMińkowski

译者：Yunooa

推荐： Spring Cloud Alibaba基础教程：使用Nacos实现服务注册与发现

上一篇：如何（不）在Java 9+中使用Reactive Streams

 关注公众号

点击原文阅读更多