当前位置： 首页 > news >正文

Spring Boot、Redis、RabbitMQ 在项目中的核心作用详解

news 2025/11/17 6:36:41

文章目录

    • 一、Spring Boot：快速开发的利器
      • 1.1 Spring Boot 的核心作用
      • 1.2 Spring Boot 项目结构
      • 1.3 Spring Boot 自动配置原理
      • 1.4 Spring Boot 在项目中的架构位置
    • 二、Redis：高性能缓存与数据存储
      • 2.1 Redis 的核心作用
      • 2.2 Redis 在 Spring Boot 中的集成
      • 2.3 Redis 缓存使用示例
      • 2.4 Redis 数据结构应用场景
      • 2.5 Redis 在系统架构中的位置
    • 三、RabbitMQ：可靠的消息中间件
      • 3.1 RabbitMQ 的核心作用
      • 3.2 RabbitMQ 在 Spring Boot 中的配置
      • 3.3 RabbitMQ 消息生产者
      • 3.4 RabbitMQ 消息消费者
      • 3.5 RabbitMQ 高级特性配置
      • 3.6 RabbitMQ 在系统架构中的消息流
    • 四、三者在项目中的协同工作
      • 4.1 完整电商订单处理流程
      • 4.2 系统架构图
      • 4.3 性能优化配置
    • 五、总结

在现代企业级应用开发中，Spring Boot、Redis 和 RabbitMQ 已经成为不可或缺的技术组件。它们各自在项目中扮演着重要角色，共同构建出高性能、高可用的分布式系统。本文将深入剖析这三者在实际项目中的作用，并通过代码示例和流程图展示它们的实际应用。

一、Spring Boot：快速开发的利器

1.1 Spring Boot 的核心作用

Spring Boot 是一个基于 Spring 框架的快速开发脚手架，其主要作用体现在：

  • 简化配置：通过自动配置和约定优于配置的原则，大幅减少 XML 配置
  • 快速启动：内嵌 Tomcat、Jetty 等 Web 容器，无需部署 WAR 包
  • 生产就绪：提供健康检查、指标监控等生产级特性
  • 微服务支持：完美支持 Spring Cloud 微服务生态

1.2 Spring Boot 项目结构

// 主启动类
@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}// 控制器层
@RestController
@RequestMapping("/api/users")
public class UserController {@Autowiredprivate UserService userService;@GetMapping("/{id}")public ResponseEntity<User> getUserById(@PathVariable Long id) {User user = userService.getUserById(id);return ResponseEntity.ok(user);}@PostMappingpublic ResponseEntity<User> createUser(@RequestBody User user) {User savedUser = userService.createUser(user);return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);}
}// 服务层
@Service
public class UserService {@Autowiredprivate UserRepository userRepository;public User getUserById(Long id) {return userRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException("User not found"));}public User createUser(User user) {return userRepository.save(user);}
}// 数据访问层
@Repository
public interface UserRepository extends JpaRepository<User, Long> {Optional<User> findByEmail(String email);
}// 实体类
@Entity
@Table(name = "users")
@Data
public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;@Column(nullable = false)private String name;@Column(nullable = false, unique = true)private String email;@CreationTimestampprivate LocalDateTime createdAt;
}

1.3 Spring Boot 自动配置原理

// 自定义 Starter 示例
@Configuration
@ConditionalOnClass(UserService.class)
@EnableConfigurationProperties(UserProperties.class)
public class UserAutoConfiguration {@Bean@ConditionalOnMissingBeanpublic UserService userService(UserProperties properties) {return new UserService(properties);}
}// 配置属性类
@ConfigurationProperties(prefix = "app.user")
@Data
public class UserProperties {private String defaultName = "Default User";private int maxAttempts = 3;
}// META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfigure.UserAutoConfiguration

1.4 Spring Boot 在项目中的架构位置

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│    Client       │───▶│  Spring Boot     │───▶│   Database      │
│   (Browser/App) │    │   Application    │    │   (MySQL/PSQL)  │
└─────────────────┘    └──────────────────┘    └─────────────────┘│                       │                       ││                       ▼                       ││              ┌─────────────────┐             │└──────────────│   Thymeleaf     │─────────────┘│   Templates     │└─────────────────┘

二、Redis：高性能缓存与数据存储

2.1 Redis 的核心作用

Redis 是一个开源的内存数据结构存储，用作数据库、缓存和消息代理，其主要作用：

  • 缓存加速：减少数据库访问，提升应用性能
  • 会话存储：分布式会话管理
  • 消息队列：通过 Pub/Sub 和 Streams 实现消息传递
  • 实时数据处理：计数器、排行榜等实时功能

2.2 Redis 在 Spring Boot 中的集成

// Redis 配置类
@Configuration
@EnableCaching
public class RedisConfig {@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {RedisTemplate<String, Object> template = new RedisTemplate<>();template.setConnectionFactory(factory);// 使用 Jackson2JsonRedisSerializer 序列化Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);ObjectMapper mapper = new ObjectMapper();mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);mapper.activateDefaultTyping(mapper.getPolymorphicTypeValidator(),ObjectMapper.DefaultTyping.NON_FINAL);serializer.setObjectMapper(mapper);template.setKeySerializer(new StringRedisSerializer());template.setValueSerializer(serializer);template.setHashKeySerializer(new StringRedisSerializer());template.setHashValueSerializer(serializer);template.afterPropertiesSet();return template;}@Beanpublic CacheManager cacheManager(RedisConnectionFactory factory) {RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(10))  // 设置缓存过期时间.disableCachingNullValues();       // 不缓存空值return RedisCacheManager.builder(factory).cacheDefaults(config).build();}
}

2.3 Redis 缓存使用示例

// 缓存服务类
@Service
public class ProductService {@Autowiredprivate ProductRepository productRepository;@Autowiredprivate RedisTemplate<String, Object> redisTemplate;private static final String PRODUCT_CACHE_KEY = "product:";private static final String PRODUCT_LIST_CACHE_KEY = "products:all";// 使用 Spring Cache 注解@Cacheable(value = "products", key = "#id")public Product getProductById(Long id) {return productRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException("Product not found"));}// 手动缓存操作public List<Product> getAllProducts() {// 先从缓存获取List<Product> products = (List<Product>) redisTemplate.opsForValue().get(PRODUCT_LIST_CACHE_KEY);if (products != null) {return products;}// 缓存未命中，查询数据库products = productRepository.findAll();// 写入缓存，设置过期时间redisTemplate.opsForValue().set(PRODUCT_LIST_CACHE_KEY, products, Duration.ofMinutes(30));return products;}// 更新缓存@CachePut(value = "products", key = "#product.id")public Product updateProduct(Product product) {Product updated = productRepository.save(product);// 清除列表缓存redisTemplate.delete(PRODUCT_LIST_CACHE_KEY);return updated;}// 删除缓存@CacheEvict(value = "products", key = "#id")public void deleteProduct(Long id) {productRepository.deleteById(id);redisTemplate.delete(PRODUCT_LIST_CACHE_KEY);}// Redis 分布式锁示例public boolean purchaseProduct(Long productId, Integer quantity) {String lockKey = "lock:product:" + productId;String requestId = UUID.randomUUID().toString();try {// 尝试获取分布式锁Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, Duration.ofSeconds(10));if (Boolean.TRUE.equals(locked)) {// 获取锁成功，执行库存扣减Product product = getProductById(productId);if (product.getStock() >= quantity) {product.setStock(product.getStock() - quantity);updateProduct(product);return true;}return false;} else {// 获取锁失败，稍后重试Thread.sleep(100);return purchaseProduct(productId, quantity);}} catch (Exception e) {throw new RuntimeException("Purchase failed", e);} finally {// 释放锁if (requestId.equals(redisTemplate.opsForValue().get(lockKey))) {redisTemplate.delete(lockKey);}}}
}

2.4 Redis 数据结构应用场景

@Service
public class RedisDataStructureService {@Autowiredprivate RedisTemplate<String, Object> redisTemplate;// String 类型：缓存、计数器public void stringOperations() {// 缓存对象User user = new User(1L, "John Doe", "john@example.com");redisTemplate.opsForValue().set("user:1", user);// 计数器redisTemplate.opsForValue().increment("page:view:home");Long views = redisTemplate.opsForValue().increment("user:1:login:count");}// Hash 类型：存储对象属性public void hashOperations() {redisTemplate.opsForHash().put("user:2", "name", "Jane Smith");redisTemplate.opsForHash().put("user:2", "email", "jane@example.com");redisTemplate.opsForHash().put("user:2", "age", "25");String name = (String) redisTemplate.opsForHash().get("user:2", "name");}// List 类型：消息队列、最新列表public void listOperations() {// 最新消息列表redisTemplate.opsForList().leftPush("recent:news", "News 1");redisTemplate.opsForList().leftPush("recent:news", "News 2");redisTemplate.opsForList().trim("recent:news", 0, 9); // 保持10条最新List<Object> recentNews = redisTemplate.opsForList().range("recent:news", 0, -1);}// Set 类型：标签、共同好友public void setOperations() {// 用户标签redisTemplate.opsForSet().add("user:1:tags", "vip", "active", "premium");redisTemplate.opsForSet().add("user:2:tags", "active", "new");// 共同标签Set<Object> commonTags = redisTemplate.opsForSet().intersect("user:1:tags", "user:2:tags");}// Sorted Set 类型：排行榜public void sortedSetOperations() {// 用户积分排行榜redisTemplate.opsForZSet().add("leaderboard", "user1", 1000);redisTemplate.opsForZSet().add("leaderboard", "user2", 1500);redisTemplate.opsForZSet().add("leaderboard", "user3", 1200);// 获取前10名Set<ZSetOperations.TypedTuple<Object>> topUsers = redisTemplate.opsForZSet().reverseRangeWithScores("leaderboard", 0, 9);}
}

2.5 Redis 在系统架构中的位置

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│  Spring Boot    │───▶│      Redis       │◀───│  Other Services │
│   Application   │    │                  │    │                 │
└─────────────────┘    └──────────────────┘    └─────────────────┘│                       ││                       │▼                       ▼
┌─────────────────┐    ┌──────────────────┐
│   Database      │    │   Message Queue  │
│   (MySQL)       │    │   (RabbitMQ)     │
└─────────────────┘    └──────────────────┘

三、RabbitMQ：可靠的消息中间件

3.1 RabbitMQ 的核心作用

RabbitMQ 是一个开源的消息代理软件，实现了高级消息队列协议（AMQP），主要作用：

  • 应用解耦：分离系统组件，降低耦合度
  • 异步处理：提高系统响应速度
  • 流量削峰：应对突发流量，保护后端系统
  • 消息分发：实现发布/订阅模式

3.2 RabbitMQ 在 Spring Boot 中的配置

// RabbitMQ 配置类
@Configuration
public class RabbitMQConfig {// 交换机public static final String EXCHANGE_ORDER = "order.exchange";public static final String EXCHANGE_NOTIFICATION = "notification.exchange";// 队列public static final String QUEUE_ORDER_CREATE = "order.create.queue";public static final String QUEUE_ORDER_CANCEL = "order.cancel.queue";public static final String QUEUE_NOTIFICATION_EMAIL = "notification.email.queue";public static final String QUEUE_NOTIFICATION_SMS = "notification.sms.queue";// 路由键public static final String ROUTING_KEY_ORDER_CREATE = "order.create";public static final String ROUTING_KEY_ORDER_CANCEL = "order.cancel";public static final String ROUTING_KEY_NOTIFICATION_ALL = "notification.#";// 订单交换机（Direct）@Beanpublic DirectExchange orderExchange() {return new DirectExchange(EXCHANGE_ORDER);}// 通知交换机（Topic）@Beanpublic TopicExchange notificationExchange() {return new TopicExchange(EXCHANGE_NOTIFICATION);}// 订单创建队列@Beanpublic Queue orderCreateQueue() {return new Queue(QUEUE_ORDER_CREATE, true); // durable=true}// 订单取消队列@Beanpublic Queue orderCancelQueue() {return new Queue(QUEUE_ORDER_CANCEL, true);}// 邮件通知队列@Beanpublic Queue emailNotificationQueue() {return new Queue(QUEUE_NOTIFICATION_EMAIL, true);}// 短信通知队列@Beanpublic Queue smsNotificationQueue() {return new Queue(QUEUE_NOTIFICATION_SMS, true);}// 绑定关系@Beanpublic Binding bindingOrderCreate(Queue orderCreateQueue, DirectExchange orderExchange) {return BindingBuilder.bind(orderCreateQueue).to(orderExchange).with(ROUTING_KEY_ORDER_CREATE);}@Beanpublic Binding bindingOrderCancel(Queue orderCancelQueue, DirectExchange orderExchange) {return BindingBuilder.bind(orderCancelQueue).to(orderExchange).with(ROUTING_KEY_ORDER_CANCEL);}@Beanpublic Binding bindingEmailNotification(Queue emailNotificationQueue, TopicExchange notificationExchange) {return BindingBuilder.bind(emailNotificationQueue).to(notificationExchange).with(ROUTING_KEY_NOTIFICATION_ALL);}@Beanpublic Binding bindingSmsNotification(Queue smsNotificationQueue, TopicExchange notificationExchange) {return BindingBuilder.bind(smsNotificationQueue).to(notificationExchange).with(ROUTING_KEY_NOTIFICATION_ALL);}// JSON 消息转换器@Beanpublic MessageConverter jsonMessageConverter() {return new Jackson2JsonMessageConverter();}
}

3.3 RabbitMQ 消息生产者

@Service
public class OrderMessageProducer {@Autowiredprivate RabbitTemplate rabbitTemplate;// 发送订单创建消息public void sendOrderCreateMessage(Order order) {try {OrderMessage message = new OrderMessage(order.getId(),order.getUserId(),order.getTotalAmount(),order.getStatus(),LocalDateTime.now());rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_ORDER,RabbitMQConfig.ROUTING_KEY_ORDER_CREATE,message,new CorrelationData(order.getId().toString()));log.info("Order create message sent: {}", order.getId());} catch (Exception e) {log.error("Failed to send order create message", e);throw new MessageSendException("Failed to send order message");}}// 发送订单取消消息public void sendOrderCancelMessage(Long orderId, String reason) {OrderCancelMessage message = new OrderCancelMessage(orderId, reason, LocalDateTime.now());rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_ORDER,RabbitMQConfig.ROUTING_KEY_ORDER_CANCEL,message);log.info("Order cancel message sent: {}", orderId);}// 发送通知消息public void sendNotification(Notification notification) {rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NOTIFICATION,"notification." + notification.getType(),notification);}
}// 订单消息DTO
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrderMessage {private Long orderId;private Long userId;private BigDecimal totalAmount;private String status;private LocalDateTime timestamp;
}// 订单取消消息DTO
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrderCancelMessage {private Long orderId;private String reason;private LocalDateTime timestamp;
}

3.4 RabbitMQ 消息消费者

@Component
public class OrderMessageConsumer {@Autowiredprivate InventoryService inventoryService;@Autowiredprivate EmailService emailService;@Autowiredprivate NotificationService notificationService;// 处理订单创建消息@RabbitListener(queues = RabbitMQConfig.QUEUE_ORDER_CREATE)public void handleOrderCreate(OrderMessage message) {try {log.info("Processing order create message: {}", message.getOrderId());// 扣减库存inventoryService.deductInventory(message.getOrderId());// 发送确认邮件emailService.sendOrderConfirmation(message.getOrderId());// 记录处理成功log.info("Order create message processed successfully: {}", message.getOrderId());} catch (Exception e) {log.error("Failed to process order create message: {}", message.getOrderId(), e);// 可以在这里实现重试逻辑或死信队列处理throw new AmqpRejectAndDontRequeueException("Processing failed");}}// 处理订单取消消息@RabbitListener(queues = RabbitMQConfig.QUEUE_ORDER_CANCEL)public void handleOrderCancel(OrderCancelMessage message) {log.info("Processing order cancel message: {}", message.getOrderId());// 恢复库存inventoryService.restoreInventory(message.getOrderId());// 发送取消通知notificationService.sendCancelNotification(message.getOrderId(), message.getReason());}
}// 通知消息消费者
@Component
public class NotificationMessageConsumer {@Autowiredprivate EmailService emailService;@Autowiredprivate SmsService smsService;@RabbitListener(queues = RabbitMQConfig.QUEUE_NOTIFICATION_EMAIL)public void handleEmailNotification(Notification notification) {log.info("Processing email notification: {}", notification);emailService.sendNotification(notification);}@RabbitListener(queues = RabbitMQConfig.QUEUE_NOTIFICATION_SMS)public void handleSmsNotification(Notification notification) {log.info("Processing SMS notification: {}", notification);smsService.sendNotification(notification);}
}

3.5 RabbitMQ 高级特性配置

@Configuration
public class RabbitMQAdvancedConfig {// 死信交换机配置public static final String DLX_EXCHANGE = "dlx.exchange";public static final String DLX_QUEUE = "dlx.queue";public static final String DLX_ROUTING_KEY = "dlx.routing.key";// 重试队列配置public static final String RETRY_QUEUE = "order.create.retry.queue";public static final int MAX_RETRY_COUNT = 3;@Beanpublic DirectExchange dlxExchange() {return new DirectExchange(DLX_EXCHANGE);}@Beanpublic Queue dlxQueue() {return new Queue(DLX_QUEUE, true);}@Beanpublic Binding dlxBinding() {return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with(DLX_ROUTING_KEY);}// 带死信队列的订单创建队列@Beanpublic Queue orderCreateQueueWithDLX() {Map<String, Object> args = new HashMap<>();args.put("x-dead-letter-exchange", DLX_EXCHANGE);args.put("x-dead-letter-routing-key", DLX_ROUTING_KEY);args.put("x-message-ttl", 60000); // 1分钟TTLreturn new Queue(RabbitMQConfig.QUEUE_ORDER_CREATE, true, false, false, args);}// 消息确认回调@Beanpublic RabbitTemplate.ConfirmCallback confirmCallback() {return (correlationData, ack, cause) -> {if (ack) {log.info("Message confirmed with correlation data: {}", correlationData);} else {log.error("Message confirmation failed: {}, cause: {}", correlationData, cause);}};}// 消息返回回调@Beanpublic RabbitTemplate.ReturnsCallback returnsCallback() {return returned -> {log.error("Message returned: {}", returned);};}
}

3.6 RabbitMQ 在系统架构中的消息流

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Order Service │───▶│   RabbitMQ       │───▶│  Inventory      │
│                 │    │                  │    │   Service       │
└─────────────────┘    └──────────────────┘    └─────────────────┘│                       │                       ││                       │                       ││                       ▼                       ││              ┌─────────────────┐             │└─────────────▶│  Email Service  │─────────────┘└─────────────────┘││▼┌─────────────────┐│   SMS Service   │└─────────────────┘

四、三者在项目中的协同工作

4.1 完整电商订单处理流程

@Service
@Transactional
public class OrderProcessingService {@Autowiredprivate OrderService orderService;@Autowiredprivate RedisTemplate<String, Object> redisTemplate;@Autowiredprivate OrderMessageProducer messageProducer;@Autowiredprivate InventoryService inventoryService;// 创建订单的完整流程public Order createOrder(OrderRequest request) {String lockKey = "lock:user:" + request.getUserId() + ":order";String requestId = UUID.randomUUID().toString();try {// 1. 获取分布式锁，防止重复提交Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, Duration.ofSeconds(5));if (!Boolean.TRUE.equals(locked)) {throw new BusinessException("请勿重复提交订单");}// 2. 检查库存（Redis 缓存）boolean inStock = inventoryService.checkStock(request.getProductId(), request.getQuantity());if (!inStock) {throw new BusinessException("库存不足");}// 3. 创建订单Order order = orderService.createOrder(request);// 4. 发送订单创建消息到 RabbitMQmessageProducer.sendOrderCreateMessage(order);// 5. 更新 Redis 中的用户订单缓存updateUserOrderCache(order.getUserId(), order);// 6. 记录订单创建日志到 RedislogOrderCreation(order);return order;} finally {// 释放分布式锁if (requestId.equals(redisTemplate.opsForValue().get(lockKey))) {redisTemplate.delete(lockKey);}}}private void updateUserOrderCache(Long userId, Order order) {String userOrdersKey = "user:" + userId + ":orders";// 使用 Redis List 存储用户最近订单redisTemplate.opsForList().leftPush(userOrdersKey, order);redisTemplate.opsForList().trim(userOrdersKey, 0, 49); // 保留最近50条订单}private void logOrderCreation(Order order) {String orderLogKey = "order:log:" + LocalDate.now().toString();Map<String, Object> logEntry = new HashMap<>();logEntry.put("orderId", order.getId());logEntry.put("userId", order.getUserId());logEntry.put("amount", order.getTotalAmount());logEntry.put("timestamp", LocalDateTime.now());redisTemplate.opsForHash().put(orderLogKey, order.getId().toString(), logEntry);}
}

4.2 系统架构图

┌─────────────────────────────────────────────────────────────────┐
│                     Client Layer                                │
│    ┌─────────────────┐    ┌─────────────────┐                  │
│    │   Web Browser   │    │  Mobile App     │                  │
│    └─────────────────┘    └─────────────────┘                  │
│            │                           │                       │
└────────────┼───────────────────────────┼───────────────────────┘│                           │▼                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                 Spring Boot Application                         │
│    ┌─────────────────┐    ┌─────────────────┐                  │
│    │   Controller    │───▶│    Service      │                  │
│    │    Layer        │    │     Layer       │                  │
│    └─────────────────┘    └─────────────────┘                  │
│            │                           │                       │
│            ▼                           ▼                       │
│    ┌─────────────────┐    ┌─────────────────┐                  │
│    │   Redis Cache   │    │  RabbitMQ       │                  │
│    │                 │    │  Producer       │                  │
│    └─────────────────┘    └─────────────────┘                  │
└────────────┼───────────────────────────┼───────────────────────┘│                           │▼                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Backend Services                             │
│    ┌─────────────────┐    ┌─────────────────┐                  │
│    │   Database      │    │  RabbitMQ       │                  │
│    │   (MySQL)       │    │  Consumer       │                  │
│    └─────────────────┘    └─────────────────┘                  │
│            │                           │                       │
│            │                           ▼                       │
│            │                  ┌─────────────────┐              │
│            │                  │   External      │              │
│            │                  │   Services      │              │
│            │                  │ (Email/SMS/...) │              │
│            │                  └─────────────────┘              │
│            │                                                   │
│            └───────────────────────────────────────────────────┘
│                                                                │
└─────────────────────────────────────────────────────────────────┘

4.3 性能优化配置

# application.yml
spring:# Redis 配置redis:host: ${REDIS_HOST:localhost}port: ${REDIS_PORT:6379}password: ${REDIS_PASSWORD:}database: 0lettuce:pool:max-active: 20max-idle: 10min-idle: 5max-wait: 1000msshutdown-timeout: 100ms# RabbitMQ 配置rabbitmq:host: ${RABBITMQ_HOST:localhost}port: ${RABBITMQ_PORT:5672}username: ${RABBITMQ_USERNAME:guest}password: ${RABBITMQ_PASSWORD:guest}virtual-host: /# 确认模式publisher-confirm-type: correlatedpublisher-returns: true# 消费者配置listener:simple:acknowledge-mode: manualprefetch: 10concurrency: 5max-concurrency: 10retry:enabled: truemax-attempts: 3initial-interval: 1000ms# 数据源配置datasource:url: jdbc:mysql://${DB_HOST:localhost}:3306/ecommerceusername: ${DB_USERNAME:root}password: ${DB_PASSWORD:password}hikari:maximum-pool-size: 20minimum-idle: 5connection-timeout: 30000idle-timeout: 600000max-lifetime: 1800000# 自定义配置
app:cache:ttl: 30morder:timeout: 30mredis:key-prefix: "app:"

五、总结

通过本文的详细讲解，我们可以看到 Spring Boot、Redis 和 RabbitMQ 在现代分布式系统中各自扮演着重要角色：

  • Spring Boot 提供了快速开发的能力，通过自动配置和丰富的 Starter 简化了项目搭建和配置
  • Redis 作为高性能缓存和数据存储，显著提升了系统性能并提供了丰富的数据结构支持
  • RabbitMQ 实现了系统解耦和异步处理，提高了系统的可扩展性和可靠性

三者结合使用，可以构建出高性能、高可用、易扩展的现代分布式应用系统。在实际项目中，我们需要根据具体业务场景合理选择和使用这些技术，充分发挥它们的优势。

希望本文能够帮助大家更好地理解和使用 Spring Boot、Redis 和 RabbitMQ，在实际项目中构建出更加优秀的系统架构。
在这里插入图片描述

http://www.dtcms.com/a/617886.html

相关文章：

  • 做完整的网站设计需要的技术长治建立公司网站的步骤
  • 南宁京象建站公司网站建设留言板实验心得
  • AI、LLM全景图
  • pip升级已安装包方法详解
  • 【Linux日新月异(六)】CentOS 7网络命令深度解析：从传统到现代网络管理
  • LangChain 构建 AI 代理（Agent）
  • 人工智能训练师备考——3.1.1题解
  • 【RL】ORPO: Monolithic Preference Optimization without Reference Model
  • 公益平台网站怎么做网站跳出
  • QT的5种标准对话框
  • 用Rust构建一个OCR命令行工具
  • 网站代码大全国内网站设计作品欣赏
  • LeetCode 热题 100——子串——滑动窗口最大值
  • CPP（容器）STL:
  • 【Java常用API】----- Math
  • RAG 系统 “检索 - 筛选 - 生成” 完整流程
  • 时间复杂度 和 嵌入式时钟概念 有关系。 我的理由是：时钟经常需要计算频率，而频率往往需要和时间进行计数次数i 。 时间复杂度就像是计数次数i
  • 公司做普通网站建立网站地图
  • Java 大视界 -- Java 大数据在智能农业病虫害精准识别与绿色防控中的创新应用
  • 【高并发架构】从 0 到亿，从单机部署到 K8s 编排：高并发架构的 8 级演进之路
  • 基于Streamlit的交互式3D手指运动学仿真
  • 甘肃做网站找谁金种子酒业网站建设
  • 使用 Flink CDC Elasticsearch Pipeline Connector 打通 MySQL 与 Elasticsearch 的实时链路
  • 基于视频识别的大模型项目实战心得
  • Firefly-Modeler 体积雕刻：AI 概念到 3D 基模
  • 提示词工程 - (2) 指南
  • 网络安全 | 深入理解SQL注入的原理和防范
  • python之循环导入
  • 强杀服务、重启系统及断电对 TDengine 影响
  • Odoo 19 制造与会计集成深度解析报告