Spring?AMQP?詳細(xì)介紹(最新推薦)
更新時間：2026年01月04日 09:57:10 作者：廋到被風(fēng)吹走
SpringAMQP是Spring框架的高級消息隊列集成模塊,提供了與RabbitMQ等消息中間件的交互,支持聲明式編程、事務(wù)集成和可靠性機(jī)制,本文介紹Spring?AMQP?詳細(xì)知識,感興趣的朋友跟隨小編一起看看吧
Spring AMQP 詳細(xì)介紹
Spring AMQP 是 Spring 框架的高級消息隊列協(xié)議（AMQP）集成模塊，提供了與消息中間件（如 RabbitMQ、Apache Qpid、ActiveMQ Artemis）交互的聲明式、模板化編程模型。它將 Spring 的核心概念（IoC、AOP、事務(wù)）應(yīng)用于消息驅(qū)動應(yīng)用開發(fā)，是構(gòu)建分布式、異步、松耦合系統(tǒng)的關(guān)鍵組件。
一、核心定位與架構(gòu)設(shè)計
1. 解決的問題
- 消息中間件復(fù)雜性：屏蔽原生客戶端 API 的繁瑣細(xì)節(jié)
- 樣板代碼消除：自動處理連接管理、異常處理、重試邏輯
- 事務(wù)集成：與 Spring 聲明式事務(wù)無縫結(jié)合
- 消息可靠性：提供確認(rèn)（ACK）機(jī)制、死信隊列、重試策略
- 序列化抽象：統(tǒng)一的消息轉(zhuǎn)換機(jī)制，支持 JSON、XML、Avro 等
2. 模塊架構(gòu)
Spring AMQP 采用分層抽象設(shè)計：
┌─────────────────────────────────────────────────────────┐
│ Spring AMQP (抽象層) │
│ - AmqpTemplate（通用操作模板） │
│ - Message（消息抽象） │
│ - Queue/Exchange/Binding（拓?fù)涠x） │
│ - MessageConverter（轉(zhuǎn)換策略） │
└─────────────────────────────────────────────────────────┘
↓ 實現(xiàn)
┌─────────────────────────────────────────────────────────┐
│ Spring Rabbit（RabbitMQ 實現(xiàn)） │
│ - RabbitTemplate（具體實現(xiàn)） │
│ - RabbitAdmin（自動聲明拓?fù)洌? │
│ - @RabbitListener（注解驅(qū)動消費） │
│ - RabbitMQ 客戶端集成 │
└─────────────────────────────────────────────────────────┘核心原則：
- 接口抽象：基于 AMQP 0.9.1 協(xié)議（RabbitMQ）和 AMQP 1.0 協(xié)議（通用）
- 非侵入性 ：業(yè)務(wù)代碼無需依賴具體 MQ 實現(xiàn)
- 聲明式編程 ：通過注解和配置定義消息行為
二、核心概念深度解析
1. 隊列（Queue）
消息存儲的終點，支持持久化、排他、自動刪除等特性。
@Bean
public Queue durableQueue() {
return QueueBuilder.durable("order.queue") // 持久化
.exclusive() // 排他（僅限當(dāng)前連接）
.autoDelete() // 自動刪除（無消費者時）
.ttl(60000) // 消息過期時間（毫秒）
.deadLetterExchange("dlx.exchange") // 死信交換機(jī)
.deadLetterRoutingKey("dlx.key")
.maxLength(1000) // 隊列最大長度
.overflowBehavior(QueueBuilder.OverflowBehavior.rejectPublish) // 溢出策略
.build();
}
// 經(jīng)典隊列（默認(rèn)）
@Bean
public Queue classicQueue() {
return new Queue("classic.queue", true, false, false);
}
// 仲裁隊列（高可用，RabbitMQ 3.8+）
@Bean
public Queue quorumQueue() {
return QueueBuilder.durable("quorum.queue")
.quorum()
.build();
}
// 流隊列（高吞吐，RabbitMQ 3.9+）
@Bean
public Queue streamQueue() {
return QueueBuilder.durable("stream.queue")
.stream()
.build();
}2. 交換機(jī)（Exchange）
消息路由的核心，決定消息投遞到哪些隊列。
// 直連交換機(jī)（精確匹配 routing key）
@Bean
public DirectExchange directExchange() {
return ExchangeBuilder.directExchange("order.exchange")
.durable(true)
.build();
}
// 主題交換機(jī)（通配符匹配）
@Bean
public TopicExchange topicExchange() {
return ExchangeBuilder.topicExchange("log.exchange")
.durable(true)
.build();
}
// 扇形交換機(jī)（廣播到所有綁定隊列）
@Bean
public FanoutExchange fanoutExchange() {
return ExchangeBuilder.fanoutExchange("notification.exchange")
.durable(true)
.build();
}
// 頭交換機(jī)（基于消息頭匹配）
@Bean
public HeadersExchange headersExchange() {
return ExchangeBuilder.headersExchange("header.exchange")
.durable(true)
.build();
}3. 綁定（Binding）
隊列與交換機(jī)的關(guān)聯(lián)關(guān)系，包含路由規(guī)則。
// Direct 綁定
@Bean
public Binding orderBinding(
@Qualifier("order.queue") Queue queue,
@Qualifier("order.exchange") DirectExchange exchange
) {
return BindingBuilder.bind(queue)
.to(exchange)
.with("order.create"); // routing key
}
// Topic 綁定（通配符）
@Bean
public Binding errorLogBinding(
@Qualifier("error.queue") Queue queue,
@Qualifier("log.exchange") TopicExchange exchange
) {
return BindingBuilder.bind(queue)
.to(exchange)
.with("*.error"); // 匹配所有以 .error 結(jié)尾的 routing key
}
// Header 綁定
@Bean
public Binding headerBinding(
@Qualifier("priority.queue") Queue queue,
@Qualifier("header.exchange") HeadersExchange exchange
) {
return BindingBuilder.bind(queue)
.to(exchange)
.where("priority").matches("high") // 頭匹配
.and("type").matches("alert");
}三、Spring Boot 快速集成
1. 依賴引入
<dependencies>
<!-- Spring Boot AMQP Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<!-- Web 支持（可選，用于 REST 接口觸發(fā)） -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 測試支持 -->
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>2. 連接配置
spring:
rabbitmq:
# 基礎(chǔ)連接
host: 192.168.66.129
port: 5672
virtual-host: wuyulin
username: wuyulin
password: wuyulin
# 高級配置
connection-timeout: 5000
requested-heartbeat: 60
cache:
connection:
mode: CONNECTION # 緩存模式：CONNECTION 或 CHANNEL
size: 5 # 連接池大小
# 生產(chǎn)確認(rèn)
publisher-confirm-type: correlated # 啟用發(fā)布確認(rèn)
publisher-returns: true # 啟用返回消息
# 消費者確認(rèn)
listener:
simple:
acknowledge-mode: auto # auto/none/manual
prefetch: 10 # 預(yù)取數(shù)量
concurrency: 3 # 最小并發(fā)消費者
max-concurrency: 10 # 最大并發(fā)消費者
default-requeue-rejected: false # 失敗消息是否重新入隊四、消息生產(chǎn)（Producer）
1. 使用 RabbitTemplate
RabbitTemplate 是同步消息發(fā)送的核心模板。
@Service
public class OrderMessageProducer {
@Autowired
private RabbitTemplate rabbitTemplate;
// 發(fā)送字符串消息
public void sendOrderNotification(String orderId) {
String message = "訂單 " + orderId + " 已創(chuàng)建";
rabbitTemplate.convertAndSend(
"order.exchange", // exchange
"order.create", // routing key
message // message body
);
}
// 發(fā)送對象消息（自動 JSON 序列化）
public void sendOrderInfo(OrderInfo orderInfo) {
rabbitTemplate.convertAndSend(
"order.exchange",
"order.info",
orderInfo, // 自動使用 MessageConverter 轉(zhuǎn)換
message -> {
// 消息后置處理
message.getMessageProperties()
.setDeliveryMode(MessageDeliveryMode.PERSISTENT); // 持久化
return message;
}
);
}
// 異步確認(rèn)
public void sendWithConfirm(OrderInfo orderInfo) {
rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
if (ack) {
log.info("消息發(fā)送成功: {}", correlationData.getId());
} else {
log.error("消息發(fā)送失敗: {}", cause);
// 重試或記錄到失敗表
}
});
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
rabbitTemplate.convertAndSend(
"order.exchange",
"order.create",
orderInfo,
correlationData
);
}
}2. 消息轉(zhuǎn)換器配置
發(fā)送對象時必須配置 MessageConverter。
@Configuration
public class RabbitMQConfig {
// JSON 轉(zhuǎn)換器
@Bean
public Jackson2JsonMessageConverter jsonMessageConverter() {
return new Jackson2JsonMessageConverter();
}
// 自定義 RabbitTemplate
@Bean
public RabbitTemplate rabbitTemplate(
ConnectionFactory connectionFactory,
Jackson2JsonMessageConverter converter
) {
RabbitTemplate template = new RabbitTemplate(connectionFactory);
template.setMessageConverter(converter);
// 啟用發(fā)布確認(rèn)
template.setConfirmCallback((correlationData, ack, cause) -> {
if (ack) {
log.info("消息確認(rèn)成功: {}", correlationData);
} else {
log.error("消息確認(rèn)失敗: {}", cause);
}
});
// 啟用返回回調(diào)（路由失?。?
template.setReturnsCallback(returned -> {
log.error("消息被退回: {}, 原因: {}",
returned.getMessage(), returned.getReplyText());
});
return template;
}
}五、消息消費（Consumer）
1. 使用 @RabbitListener 注解
注解驅(qū)動的方式是 Spring AMQP 最強(qiáng)大的特性。
@Component
public class OrderMessageConsumer {
// 基礎(chǔ)消費
@RabbitListener(queues = "order.queue")
public void handleOrderMessage(String message) {
log.info("收到訂單消息: {}", message);
// 業(yè)務(wù)處理
}
// 消費 OrderInfo 對象
@RabbitListener(queues = "order.info.queue")
public void handleOrderInfo(OrderInfo orderInfo) {
log.info("收到訂單: {}, 金額: {}",
orderInfo.getOrderId(), orderInfo.getPrice());
// 處理訂單邏輯
}
// 手動確認(rèn)模式
@RabbitListener(queues = "order.manual.queue")
public void handleManualAck(
OrderInfo orderInfo,
Channel channel,
@Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag
) throws IOException {
try {
// 業(yè)務(wù)處理
log.info("處理訂單: {}", orderInfo.getOrderId());
// 手動 ACK
channel.basicAck(deliveryTag, false);
} catch (Exception e) {
// 拒絕消息（requeue=false 進(jìn)入死信隊列）
channel.basicNack(deliveryTag, false, false);
}
}
// 批量消費
@RabbitListener(queues = "order.batch.queue")
public void handleBatchOrder(List<OrderInfo> orders) {
log.info("批量收到 {} 個訂單", orders.size());
// 批量處理
}
}2. 動態(tài)創(chuàng)建監(jiān)聽器
@Service
public class DynamicConsumerService {
@Autowired
private RabbitListenerEndpointRegistry registry;
// 運行時動態(tài)注冊消費者
public void registerListener(String queueName) {
SimpleMessageListenerContainer container =
new SimpleMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
container.setQueueNames(queueName);
container.setMessageListener(message -> {
log.info("動態(tài)消費: {}", new String(message.getBody()));
});
container.start();
}
}六、高級消息模式
1. 發(fā)布確認(rèn)（Publisher Confirms）
避免消息丟失的關(guān)鍵機(jī)制。
@Configuration
public class ProducerConfirmConfig {
@Bean
public RabbitTemplate rabbitTemplate(ConnectionFactory factory) {
RabbitTemplate template = new RabbitTemplate(factory);
// 確認(rèn)回調(diào)
template.setConfirmCallback((correlationData, ack, cause) -> {
if (ack) {
// 更新數(shù)據(jù)庫狀態(tài)為"已發(fā)送"
messageLogService.markAsSent(correlationData.getId());
} else {
// 記錄失敗原因，觸發(fā)告警
messageLogService.markAsFailed(correlationData.getId(), cause);
}
});
// 返回回調(diào)（路由失敗）
template.setReturnsCallback(returned -> {
log.error("消息無法路由: {}, 路由鍵: {}",
returned.getMessage(), returned.getRoutingKey());
});
return template;
}
}2. 消費者確認(rèn)（Consumer Ack）
spring:
rabbitmq:
listener:
simple:
acknowledge-mode: manual # 手動確認(rèn)
prefetch: 5 # 預(yù)取 5 條，處理完再獲取@RabbitListener(queues = "order.queue")
public void handleWithAck(
OrderInfo order,
Channel channel,
@Header(AmqpHeaders.DELIVERY_TAG) long tag
) throws IOException {
try {
// 1. 業(yè)務(wù)處理
orderService.process(order);
// 2. 確認(rèn)消息
channel.basicAck(tag, false);
} catch (BusinessException e) {
// 3. 拒絕消息（不重新入隊 → 死信隊列）
channel.basicNack(tag, false, false);
} catch (Exception e) {
// 4. 重試（重新入隊）
channel.basicNack(tag, false, true);
}
}3. 死信隊列（DLQ）
@Configuration
public class DLQConfig {
// 主隊列
@Bean
public Queue mainQueue() {
return QueueBuilder.durable("order.queue")
.deadLetterExchange("dlx.exchange")
.deadLetterRoutingKey("dlx.order")
.ttl(60000) // 消息超時時間
.maxLength(1000)
.build();
}
// 死信交換機(jī)
@Bean
public DirectExchange dlxExchange() {
return new DirectExchange("dlx.exchange");
}
// 死信隊列
@Bean
public Queue dlxQueue() {
return QueueBuilder.durable("dlx.order.queue").build();
}
// 綁定
@Bean
public Binding dlxBinding() {
return BindingBuilder.bind(dlxQueue())
.to(dlxExchange())
.with("dlx.order");
}
// 死信消費者
@RabbitListener(queues = "dlx.order.queue")
public void handleDeadLetter(OrderInfo order) {
log.error("處理死信訂單: {}, 原因: {}",
order.getOrderId(), order.getFailureReason());
// 記錄日志、發(fā)送告警、人工介入
}
}4. 延遲隊列
RabbitMQ 通過死信隊列 + TTL實現(xiàn)延遲。
@Bean
public Queue delayQueue() {
return QueueBuilder.durable("delay.queue")
.deadLetterExchange("order.exchange")
.deadLetterRoutingKey("order.create")
.ttl(300000) // 5 分鐘后過期 → 轉(zhuǎn)投主隊列
.build();
}
// 發(fā)送延遲消息
public void sendDelayMessage(OrderInfo order) {
rabbitTemplate.convertAndSend(
"delay.exchange",
"delay.key",
order
);
}七、錯誤處理與重試
1. 容器級重試
@Configuration
public class RetryConfig {
@Bean
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
ConnectionFactory connectionFactory,
Jackson2JsonMessageConverter converter
) {
SimpleRabbitListenerContainerFactory factory =
new SimpleRabbitListenerContainerFactory();
factory.setConnectionFactory(connectionFactory);
factory.setMessageConverter(converter);
factory.setDefaultRequeueRejected(false); // 重試后不再入隊
// 重試策略
factory.setAdviceChain(
RetryInterceptorBuilder.stateless()
.maxAttempts(3) // 最大重試次數(shù)
.backOffOptions(1000, 2.0, 10000) // 初始間隔、倍數(shù)、最大間隔
.recoverer(new RejectAndDontRequeueRecoverer()) // 耗盡重試后進(jìn)入 DLQ
.build()
);
return factory;
}
}2. 自定義 Recoverer
@Component
public class CustomMessageRecoverer implements MessageRecoverer {
@Autowired
private RabbitTemplate rabbitTemplate;
@Override
public void recover(Message message, Throwable cause) {
log.error("消息消費失敗，進(jìn)入死信隊列: {}", message);
// 記錄失敗原因到消息頭
MessageProperties props = message.getMessageProperties();
props.setHeader("x-exception-stacktrace", ExceptionUtils.getStackTrace(cause));
props.setHeader("x-original-exchange", props.getReceivedExchange());
props.setHeader("x-original-routing-key", props.getReceivedRoutingKey());
// 發(fā)送到死信隊列
rabbitTemplate.send("dlx.exchange", "dlx.failed", message);
}
}八、Spring Integration 集成
Spring Integration 提供了通道適配器實現(xiàn)消息驅(qū)動架構(gòu)。
<!-- 依賴 -->
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-amqp</artifactId>
<version>7.0.1</version>
</dependency>@Configuration
@EnableIntegration
public class IntegrationConfig {
// 入站通道適配器（接收）
@Bean
public AmqpInboundChannelAdapter inboundAdapter(
ConnectionFactory factory,
MessageChannel outputChannel
) {
AmqpInboundChannelAdapter adapter = new AmqpInboundChannelAdapter(
new SimpleMessageListenerContainer(factory)
);
adapter.setQueueNames("order.queue");
adapter.setOutputChannel(outputChannel);
return adapter;
}
// 出站通道適配器（發(fā)送）
@Bean
@ServiceActivator(inputChannel = "toRabbit")
public AmqpOutboundEndpoint outboundEndpoint(
RabbitTemplate rabbitTemplate
) {
AmqpOutboundEndpoint endpoint = new AmqpOutboundEndpoint(rabbitTemplate);
endpoint.setExchangeName("order.exchange");
endpoint.setRoutingKey("order.create");
return endpoint;
}
// 請求-應(yīng)答網(wǎng)關(guān)
@Bean
public AmqpInboundGateway inboundGateway(
ConnectionFactory factory,
MessageChannel requestChannel
) {
AmqpInboundGateway gateway = new AmqpInboundGateway(
new SimpleMessageListenerContainer(factory)
);
gateway.setQueueNames("rpc.queue");
gateway.setRequestChannel(requestChannel);
return gateway;
}
}九、性能調(diào)優(yōu)與監(jiān)控
1. 連接與通道優(yōu)化
spring:
rabbitmq:
cache:
connection:
mode: CHANNEL # CHANNEL 模式性能更好
size: 25 # 通道緩存大小
channel:
checkout-timeout: 1000 # 獲取通道超時時間2. 消費者性能
spring:
rabbitmq:
listener:
simple:
concurrency: 5 # 初始消費者數(shù)
max-concurrency: 20 # 最大消費者數(shù)
prefetch: 10 # 每個消費者預(yù)取數(shù)量
receive-timeout: 2000 # 接收超時3. 指標(biāo)監(jiān)控（Actuator）
management:
endpoints:
web:
exposure:
include: metrics,health,rabbitmq// 自定義指標(biāo)
@Component
public class RabbitMetrics {
private final Counter messageCounter;
public RabbitMetrics(MeterRegistry registry) {
this.messageCounter = Counter.builder("rabbitmq.messages.sent")
.description("Total messages sent to RabbitMQ")
.register(registry);
}
public void increment() {
messageCounter.increment();
}
}十、最佳實踐與避坑指南
1. 生產(chǎn)環(huán)境清單
? 啟用發(fā)布確認(rèn)（publisher-confirm-type: correlated）
? 啟用消費者手動 ACK（acknowledge-mode: manual）
? 配置死信隊列處理失敗消息
? 設(shè)置合理的 prefetch 避免消費者過載
? 消息冪等性設(shè)計（唯一 ID + 去重表）
? 監(jiān)控隊列深度和消費者滯后
? 使用連接池避免頻繁創(chuàng)建連接
2. 常見陷阱
? 自動 ACK + 業(yè)務(wù)異常 → 消息丟失
? 未設(shè)置 TTL → 隊列無限堆積
? 無死信隊列 → 無法排查失敗消息
? 大消息體 → 性能下降，改用對象存儲 + 消息引用
? routing key 硬編碼 → 維護(hù)困難，改用常量或配置
3. 消息設(shè)計模式
// 統(tǒng)一消息體
@Data
public class MessageWrapper<T> {
private String messageId;
private Long timestamp;
private String source;
private T payload;
private Map<String, Object> headers;
}
// 發(fā)送時
MessageWrapper<OrderInfo> wrapper = new MessageWrapper<>();
wrapper.setMessageId(UUID.randomUUID().toString());
wrapper.setPayload(orderInfo);
wrapper.setHeaders(Map.of("retry-count", 0));
rabbitTemplate.convertAndSend("exchange", "key", wrapper);十一、總結(jié)
Spring AMQP 核心價值
| 維度 | 原生 RabbitMQ 客戶端 | Spring AMQP |
|---|---|---|
| 開發(fā)效率 | 樣板代碼多 | 聲明式開發(fā)，效率提升 80% |
| 可靠性 | 手動實現(xiàn) | 內(nèi)置確認(rèn)、重試、死信機(jī)制 |
| 可維護(hù)性 | 配置分散 | 統(tǒng)一配置，強(qiáng)類型安全 |
| 生態(tài)集成 | 需適配 | 無縫集成 Spring 全家桶 |
| 監(jiān)控觀測 | 無 | Actuator + Metrics 原生支持 |
適用場景
- ? 微服務(wù)異步通信：訂單創(chuàng)建 → 庫存扣減 → 物流通知
- ? 任務(wù)解耦：報表生成、郵件發(fā)送、短信通知
- ? 流量削峰：秒殺活動緩沖、日志收集
- ? 數(shù)據(jù)同步：跨系統(tǒng)數(shù)據(jù)復(fù)制
- ? 事件驅(qū)動：領(lǐng)域事件發(fā)布/訂閱
演進(jìn)趨勢
- 響應(yīng)式支持：
ReactiveRabbitTemplate（Spring AMQP 3.x） - 云原生：與 K8s Service Mesh 集成，mTLS 通信
- 流處理：RabbitMQ Streams 支持高吞吐場景
- Serverless：AWS Lambda + RabbitMQ 觸發(fā)器
Spring AMQP 通過優(yōu)雅的抽象和強(qiáng)大的注解，將消息驅(qū)動開發(fā)的復(fù)雜度降至最低，是 Java 微服務(wù)架構(gòu)中異步通信的首選方案。
到此這篇關(guān)于Spring AMQP 詳細(xì)介紹的文章就介紹到這了,更多相關(guān)Spring AMQP 介紹內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
使用postman傳遞list集合后臺springmvc接收
這篇文章主要介紹了使用postman傳遞list集合后臺springmvc接收的操作，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-08-08
這篇文章主要介紹了Java wait和notify虛假喚醒,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-04-04
這篇文章主要介紹了idea指定啟動參數(shù)、環(huán)境變量的操作過程，本文通過圖文并茂的形式給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值,需要的朋友可以參考下2023-07-07
這篇文章主要詳細(xì)的介紹了shenJava顯式鎖常用的api及標(biāo)準(zhǔn)用法，感興趣的朋友,需要的朋友可以參考下面文章里的內(nèi)容2021-09-09
這篇文章主要為大家詳細(xì)介紹了SpringCloud使用Feign文件上傳、下載功能，具有一定的參考價值，感興趣的小伙伴們可以參考一下2019-04-04
這篇文章主要為大家詳細(xì)介紹了java poi解析word的方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-05-05
Java?17新特性從語言增強(qiáng)到運行時優(yōu)化完全解析
Java17是Java編程語言的一個新版本,它引入了一些新的特性和改進(jìn),使得Java編程更加高效和方便,這篇文章主要介紹了Java 17新特性從語言增強(qiáng)到運行時優(yōu)化的相關(guān)資料,需要的朋友可以參考下2026-05-05
聊一聊SpringBoot服務(wù)監(jiān)控機(jī)制
這篇文章主要介紹了聊一聊SpringBoot服務(wù)監(jiān)控機(jī)制，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-04-04
springboot使用Thymeleaf報錯常見的幾種解決方案
這篇文章主要介紹了springboot使用Thymeleaf報錯常見的幾種解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-11-11
java servlet手機(jī)app訪問接口(二)短信驗證
這篇文章主要介紹了java servlet手機(jī)app訪問接口(二)，短信驗證，具有一定的參考價值，感興趣的小伙伴們可以參考一下2016-12-12