2020最新RabbitMQ图文教程通俗易懂版（下）【内附视频链接】

最新推荐文章于 2023-11-14 14:36:44 发布
最新推荐文章于 2023-11-14 14:36:44 发布
阅读量325 收藏
点赞数
文章标签： 队列 rabbitmq 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Blog_rookie/article/details/111617292
版权

RabbitMQ消息的事务机制

在使用RabbitMQ的时候，我们可以通过消息持久化操作来解决因为服务器的异常奔溃导致的消息丢失，除此之外我们还会遇到一个问题，当消息的发布者在将消息发送出去之后，消息到底有没有正确到达broker代理服务器呢？如果不进行特殊配置的话，默认情况下发布操作是不会返回任何信息给生产者的，也就是默认情况下我们的生产者是不知道消息有没有正确到达broker的，如果在消息到达broker之前已经丢失的话，持久化操作也解决不了这个问题，因为消息根本就没到达代理服务器，你怎么进行持久化，那么这个问题该怎么解决呢？

RabbitMQ为我们提供了两种方式：

  • 通过AMQP事务机制实现，这也是AMQP协议层面提供的解决方案；

  • 通过将channel设置成confirm模式来实现；

AMQP事物机制控制

RabbitMQ中与事务机制有关的方法有三个：txSelect(), txCommit()以及txRollback(), txSelect()用于将当前channel设置成transaction模式，txCommit()用于提交事务，txRollback()用于回滚事务，在通过txSelect()开启事务之后，我们便可以发布消息给broker代理服务器了，如果txCommit()提交成功了，则消息一定到达了broker了，如果在txCommit()执行之前broker异常崩溃或者由于其他原因抛出异常，这个时候我们便可以捕获异常通过txRollback()回滚事务。

SendTx.java

try {
    // 通过工厂创建连接
    connection = factory.newConnection();
    // 获取通道
    channel = connection.createChannel();
    // 开启事务
    channel.txSelect();
    // 声明队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    // 创建消息
    String message = "Hello World!";
    // 将产生的消息放入队列
    channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
    System.out.println(" [x] Sent '" + message + "'");
    // 模拟程序异常
    int i = 1 / 0;
    // 提交事务
    channel.txCommit();
} catch (IOException | TimeoutException e) {
    e.printStackTrace();
    try {
        // 回滚事务
        channel.txRollback();
    } catch (IOException e1) {
        e1.printStackTrace();
    }
}

事务确实能够解决producer与broker之间消息确认的问题，只有消息成功被broker接受，事务提交才能成功，否则我们便可以在捕获异常进行事务回滚操作同时进行消息重发，但是使用事务机制的话会降低RabbitMQ的性能，那么有没有更好的方法既能保障producer知道消息已经正确送到，又能基本上不带来性能上的损失呢？从AMQP协议的层面看是没有更好的方法，但是RabbitMQ提供了一个更好的方案，即将channel信道设置成confirm模式。

confirm确认模式

通过AMQP协议层面为我们提供了事务机制解决了这个问题，但是采用事务机制实现会降低RabbitMQ的消息吞吐量，此时处理AMQP协议层面能够实现消息事物控制外，我们还有第二种方式即:Confirm模式。

Confirm确认模式原理

生产者将信道设置成confirm模式，一旦信道进入confirm模式，所有在该信道上面发布的消息都会被指派一个唯一的ID(从1开始)，一旦消息被投递到所有匹配的队列之后，broker就会发送一个确认给生产者（包含消息的唯一ID）,这就使得生产者知道消息已经正确到达目的队列了，如果消息和队列是可持久化的，那么确认消息会将消息写入磁盘之后发出，broker回传给生产者的确认消息中deliver-tag域包含了确认消息的序列号，此外broker也可以设置basic.ack的multiple域，表示到这个序列号之前的所有消息都已经得到了处理。

confirm模式最大的好处在于他是异步的，一旦发布一条消息，生产者应用程序就可以在等信道返回确认的同时继续发送下一条消息，当消息最终得到确认之后，生产者应用便可以通过回调方法来处理该确认消息，如果RabbitMQ因为自身内部错误导致消息丢失，就会发送一条nack消息，生产者应用程序同样可以在回调方法中处理该nack消息。

在channel 被设置成 confirm 模式之后，所有被 publish 的后续消息都将被 confirm（即 ack） 或者被nack一次。但是没有对消息被 confirm 的快慢做任何保证，并且同一条消息不会既被 confirm又被nack 。

注意:两种事物控制形式不能同时开启！

Confirm确认机制代码实现

实现生产者confirm 机制有三种方式:

  • 普通confirm模式：每发送一条消息后，调用waitForConfirms()方法，等待服务器端confirm。实际上是一种串行confirm了。

  • 批量confirm模式：每发送一批消息后，调用waitForConfirmsOrDie()方法，等待服务器端confirm。

  • 异步confirm模式：提供一个回调方法，服务端confirm了一条或者多条消息后Client端会回调这个方法。

同步Confirm

SendConfirmSync.java

try {
    // 通过工厂创建连接
    connection = factory.newConnection();
    // 获取通道
    channel = connection.createChannel();
    // 开启confirm确认模式
    channel.confirmSelect();
    // 声明队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    // 创建消息
    String message = "Hello World!";
    // 将产生的消息放入队列
    channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
    System.out.println(" [x] Sent '" + message + "'");
    // 确认消息是否发送成功-单条
    if (channel.waitForConfirms())
        System.out.println("消息发送成功！");
    else
        System.out.println("消息发送失败！");
    // 确认消息是否发送成功-多条
    // 直到所有消息都确认，只要有一个未确认就会IOException
    channel.waitForConfirmsOrDie();
    System.out.println("消息发送成功！");
}

以上代码可以看出，使用同步的方式需要等所有的消息发送成功以后才会执行后面代码，只要有一个消息未被确认就会抛出IO异常。解决办法可以使用异步确认。

异步confirm

异步confirm模式的编程实现最复杂，Channel对象提供的ConfirmListener()回调方法只包含deliveryTag（当前Chanel发出的消息序号），我们需要自己为每一个Channel维护一个unconfirm的消息序号集合，每publish一条数据，集合中元素加1，每回调一次handleAck方法，unconfirm集合删掉相应的一条（multiple=false）或多条（multiple=true）记录。从程序运行效率上看，这个unconfirm集合最好采用有序集合SortedSet存储结构。实际上，waitForConfirms()方法也是通过SortedSet维护消息序号的。

SendConfirmAsync.java

package com.xxxx.confirm.async.send;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.Collections;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.TimeoutException;

/**
 * 信道确认模式-异步-生产者
 */
public class Send {

	// 队列名称
	public static final String QUEUE_NAME = "confirm_async";

	public static void main(String[] args) {
		// 定义连接工厂
		ConnectionFactory factory = new ConnectionFactory();
		factory.setPort(5672);
		factory.setHost("192.168.10.100");
		factory.setUsername("shop");
		factory.setPassword("shop");
		factory.setVirtualHost("/shop");

		Connection connection = null;
		Channel channel = null;
		try {
			// 维护信息发送回执deliveryTag
			final SortedSet<Long> confirmSet=Collections.synchronizedSortedSet(new TreeSet<Long>());
			// 创建连接
			connection = factory.newConnection();
			// 获取通道
			channel = connection.createChannel();
			// 开启confirm确认模式
			channel.confirmSelect();
			// 声明队列
			channel.queueDeclare(QUEUE_NAME, false, false, false, null);
			// 添加channel 监听
			channel.addConfirmListener(new ConfirmListener() {
				// 已确认
				@Override
				public void handleAck(long deliveryTag, boolean multiple) throws IOException {
					// multiple=true已确认多条 false已确认单条
					if (multiple) {
						System.out.println("handleAck--success-->multiple" + deliveryTag);
						// 清除前 deliveryTag 项标识id
						confirmSet.headSet(deliveryTag + 1L).clear();
					} else {
						System.out.println("handleAck--success-->single" + deliveryTag);
						confirmSet.remove(deliveryTag);
					}
				}

				// 未确认
				@Override
				public void handleNack(long deliveryTag, boolean multiple) throws IOException {
					// multiple=true未确认多条 false未确认单条
					if (multiple) {
						System.out.println("handleNack--failed-->multiple-->" + deliveryTag);
						// 清除前 deliveryTag 项标识id
						confirmSet.headSet(deliveryTag + 1L).clear();
					} else {
						System.out.println("handleNack--failed-->single" + deliveryTag);
						confirmSet.remove(deliveryTag);
					}
				}
			});
			// 循环发送消息演示消息确认
			while (true) {
				// 创建消息
				String message = "Hello World!";
				// 获取unconfirm的消息序号deliveryTag
				Long seqNo = channel.getNextPublishSeqNo();
				channel.basicPublish("", QUEUE_NAME, null, message.getBytes("utf-8"));
				// 将消息序号deliveryTag添加至SortedSet
				confirmSet.add(seqNo);
			}
		} catch (IOException | TimeoutException e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭通道
				if (null != channel && channel.isOpen())
					channel.close();
				// 关闭连接
				if (null != connection && connection.isOpen())
					connection.close();
			} catch (TimeoutException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

异步模式的优点就是执行效率高，不需要等待消息执行完，只需要监听消息即可。

Spring集成RabbitMQ

官网：https://spring.io/projects/spring-amqp

为什么使用spring AMQP？

  • 基于Spring之上社区活跃

  • 对AMQP协议进行了高度的封装

  • 极大的简化了RabbitMQ的操作

  • 易用性、可扩展

创建聚合项目

创建父项目spring-rabbitmq

创建rabbitmq-provider

鼠标右键spring-rabbitmq项目new -> Module

创建rabbitmq-consumer

鼠标右键spring-rabbitmq项目new -> Module

父项目依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <modules>
        <module>rabbitmq-provider</module>
        <module>rabbitmq-consumer</module>
    </modules>

    <groupId>com.xxxx</groupId>
    <artifactId>spring-rabbitmq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>srping-rabbitmq</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

</project>

编写生产者

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.xxxx</groupId>
        <artifactId>spring-rabbitmq</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.xxxx</groupId>
    <artifactId>rabbitmq-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rabbitmq-provider</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

application.yml

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: shop
    password: shop
    virtual-host: /shop
server:
  port: 8081

RabbitmqConfig.java

package com.xxxx.rabbitmqprovider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqConfig {
    /**
     * 申明队列
     * @return
     */
    @Bean
    public Queue queue(){
        return new Queue("topics");
    }

    /**
     * 申明交换机（主题模式）
     * @return
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }

    /**
     * 将队列绑定到交换机
     * @return
     */
    @Bean
    public Binding binding(){
        return BindingBuilder.bind(queue()).to(topicExchange()).with("topic.msg");
    }
}

Send.java

package com.xxxx.rabbitmqprovider.send;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Sender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send() {
        String message = "Hello World!";
        /**
         * 第一个参数：交换机名称
         * 第二个参数：路由key名称
         * 第三个参数：发送的消息
         */
        rabbitTemplate.convertAndSend("topicExchange", "topic.msg", message);
        System.out.println("发送：" + message);
    }
}

RabbitmqProviderTestApplication.java

package com.xxxx.rabbitmqprovider;

import com.xxxx.rabbitmqprovider.send.Sender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = RabbitmqProviderApplication.class)
public class  {
    @Autowired
    private Sender sender;

    @Test
    public void testSend(){
        sender.send();
    }
}

编写消费者

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.xxxx</groupId>
        <artifactId>spring-rabbitmq</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <groupId>com.xxxx</groupId>
    <artifactId>rabbitmq-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rabbitmq-consumer</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

application.yml

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: shop
    password: shop
    virtual-host: /shop
server:
  port: 8082

Consumer.java

package com.xxxx.rabbitmqconsumer.revc;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
//监听队列
@RabbitListener(queues = "topics")
public class Consumer {
    //表示接收消息后的处理方法
    @RabbitHandler
    public void recv(String message){
        System.out.println("接收消息："+message);
    }
}

测试

总结

当然这是官网最简单的例子，以后如果项目是基于配置来做的话要掌握以下：

  1. pom中引用jar

  2. 先配置rabbitmq的配置

    1. 先配置ConnectionFactory
    2. 配置RabbitAmdmin

  3. 配置RabbitTemplate这里通常在配置一个Message Convert使用JSON进行数据格式的传输

  4. 配置Exchange

  5. 配置Queue

  6. 配置一个消息处理的bean或者通过Spring扫描，这个Bean最后继承MessageListener 来处理JSON数据

  7. 配置Listener Container

去看视频了解

Blog_rookie
关注
kafka 事务_Kafka 事务实现原理
weixin_35550400的博客
12-10 1432
Kafka 事务实现原理Kafka 事务在流处理中应用很广泛，比如原子性的读取消息，立即处理和发送，如果中途出现错误，支持回滚操作。这篇文章来讲讲事务是如何实现的，首先来看看事务流程图。事务流程Kafka的整个事务处理流程如下图：上图中的 Transaction Coordinator 运行在 Kafka 服务端，下面简称 TC 服务。__transaction_state 是 TC 服...
消息中间件如何实现幂等性
dembo的博客
08-10 964
消息中间件的幂等性，一般有两种实现方式，基于业务实现幂等性和不基于业务实现幂等性。 如果业务场景比较简单，可以基于业务实现。比如：消费端处理购买商品的订单，订单表新增数据，并把库存表中该商品的库存减少。消费端处理开通会员的订单，订单表新增一条记录，并把该用户的会员时间新增一个月。这种比较简单的业务场景，可以考虑基于业务实现。该场景下肯定要确保订单的插入和库存减少在一个事务中，否则消费到一半，订单增加了，库存没有减少，重新消费的时候就会出错。那么如果当订单插入成功，并且库存也...
消息队列之事务消息，RocketMQ 和 Kafka是如何做的？
HollisChuang's Blog
09-14 561
一说起事务相信大家都不陌生，脑海里蹦出来的就是 ACID。通常我们理解的事务就是为了一些更新操作要么都成功，要么都失败，不会有中间状态的产生，而 ACID 是一个严格的事务实现的定义，不...
消息中间件幂等性
古笑来的博客
10-25 152
消息重复问题？如何保证消息的幂等性？ 所有的mq都没有主动解决幂等性的机制，需要应用自己控制。在消息中增加唯一键或者别的什么标识，每次业务计算前看一下有没有消费过相同的记录（应用初始化的话后消费的消息都校验，在没有重复消费后边的消息就不校验了）。 ...
5.Kafka客户端事务原理
义笔记
06-25 6192
kafka 客户端事务实现原理 kafka事务在流处理中应用很广泛，比如原子性的读取消息，立即发送消息，如果中途出现错误，支持会滚操作。这里会讲解一下Kafka事务是如何实现的。 Producer顶层实现 事务的客户端中，只能是Producer（KafkaProducer的顶层实现） public interface Producer<K, V> extends Closeable { //事务初始化，包括申请 producer id void initTransactions(
最新最全rabbitmq与erlang版本匹配-2020-04-23.docx
04-23
- 为了获得最佳的性能和安全性，建议始终使用最新版本的Erlang/OTP，同时确保该版本与当前运行的RabbitMQ版本兼容。 - 定期检查RabbitMQ和Erlang的更新，以确保及时修补安全漏洞和修复已知问题。 - 在生产环境中，...
前峰rabbitmq最新直播课涛哥亲讲-视频教程网盘链接提取码下载.txt
12-18
本课程由RabbitMQ资深讲师涛哥倾情讲解，覆盖RabbitMQ消息中间件的核心概念、实际应用及高级技巧。学员将深入理解消息队列技术，并通过实例掌握应用实战技能，为进阶架构师之路铺就坚实基础。 视频大小：791M
CentOS 7 下安装RabbitMQ教程配套的离线文件
最新发布
03-24
在本教程中，我们将深入探讨如何在 CentOS 7 操作系统上安装 RabbitMQ，这是一个流行的开源消息代理，基于AMQP（Advanced Message Queuing Protocol）协议。RabbitMQ 使用 Erlang 语言开发，它提供了一个可靠的平台...
最新最全rabbitmq与erlang版本匹配-2020-04-23.ods
04-23
最新最全rabbitmq与erlang版本匹配-2020-04-23
RabbitMQ系列教程1
08-03
【RabbitMQ系列教程1】 RabbitMQ是一个广泛使用的开源消息代理和队列服务器，它实现了高级消息队列协议（AMQP）。这个教程将引导我们深入理解RabbitMQ的核心概念和工作原理，以及如何与其他消息中间件进行比较。 1...
Kafka 事务的实现原理
大数据星球-浪尖
07-08 584
- 前言 -Kafka 事务在流处理中应用很广泛，比如原子性的读取消息，立即处理和发送，如果中途出现错误，支持回滚操作。这篇文章来讲讲事务是如何实现的，首先来看看事务流程...
kafka Transaction coordinator
lzf的博客
02-08 3305
本文转发自技术世界，原文链接　Kafka设计解析（八）- Exactly Once语义与事务机制原理  本文所有Kafka原理性的描述除特殊说明外均基于Kafka 1.0.0版本。为什么要提供事务机制Kafka事务机制的实现主要是为了支持Exactly Once即正好一次语义操作的原子性有状态操作的可恢复性Exactly Once《Kafka背景及架构介绍》一文中有说明Kafka在0.11.0.0...
Kafka事务「原理剖析」
qq_32445015的博客
11-14 335
总结一下kafka事务相关的一些topic及文件。topic只有一个，是专门为事务特性服务的，而文件有两个，这里的文件指的是所有参与事务的topic下文件Topic内部compact topic，主要是将事务状态持久化，避免Transactional Coordinator重启或切换后事务状态丢失文件.txnindex存放已经取消事务的记录，请问已经提到过，如果当前logSegment没有取消的事务，那么这个文件也不会存在.snapshot。
消息中间件可靠性和幂等性
allen的博客
03-23 436
问题1:如何消息不丢失 如何保障消息中间件 100% 消息投递成功？在kafka中可以通过ack参数配置实现： 参数为0：producer不等待ack，若beoker还未写入就返回，会造成数据丢失。 参数为1: leader写入成功后返回ack，不等待follower同步成功； 参数为-1：等待全部folleower落盘成功后返回。 ack机制并不能保证消息100%不丢失，原因如下: ...
消息中间件(三)——如何保证消息幂等性
热门推荐
zengdongwen的博客
09-06 1万+
1、什么是消息的幂等性 幂等：在编程中一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同。这是百度百科给出的幂等的概念。 消息的幂等性：就是即使多次收到了消息，也不会重复消费。所以保证消息的幂等性就是保证消息不会重复消费，这在开发中是很重要的。比如客户点击付款，如果点击了多次，那也只能扣一次费。 2、MQ的幂等性如何保证 我们所熟悉的RabbitMQ、RocketMQ、k...
android 结束if循环_简单探究Android平台下' if ' 语句条件判断耗时情况
weixin_40007668的博客
12-22 436
2017年6月13日前言前几日在改Bug时看到好多调试时用的日志语句都被一个日志开关控制着它的执行权。形如：1 if(Constants.LOG_TAG){2 Log.d(TAG, "Initialize finish! index:" + idx);3 }又为了方便日后遇到问题时的分析，还要加上很多类似的日志语句。这时突然很好奇“大量的”条件判断语句需要多消耗多少系统资源，以及不同的条件...
android 结束if循环_Android的 - 优化多个if语句
weixin_39603995的博客
12-22 146
In my application, I have many IF statements that could be optimizing, but for the life of me can't work out a good possible solution without errors.My current code:if (User_XP > -1){User_level.set...
android if 循环,Android：使用if语句循环数组
weixin_30764887的博客
05-29 959
我是Android新手，但不是编程，我必须为Masters项目创建原型应用程序。我有2个预定义数组，每个数组包含33个值。目标是让按钮单击时显示每个值的数组。最终它会做更多，但现在这不重要。Android：使用if语句循环数组我已经使用了一个简单的if/else if语句，并将其封装在try/finally块中。数组循环很漂亮，但是当我的值达到数组的末尾(32)并增加到最后(33)时，它不会绕过第...
消息队列之事务消息，RocketMQ 和 Kafka 是如何做的？
yes
08-31 603
每个时代，都不会亏待会学习的人。 大家好，我是 yes。 今天我们来谈一谈消息队列的事务消息，一说起事务相信大家都不陌生，脑海里蹦出来的就是 ACID。 通常我们理解的事务就是为了一些更新操作要么都成功，要么都失败，不会有中间状态的产生，而 ACID 是一个严格的事务实现的定义，不过在单体系统时候一般都不会严格的遵循 ACID 的约束来实现事务，更别说分布式系统了。 分布式系统往往只能妥协到最终一致性，保证数据最终的完整性和一致性，主要原因就是实力不允许…因为可用性为王。 而且要保证完全版的事务实现代价.
RabbitMQ基础教程-中文版
"这篇教程是RabbitMQ开发的中文翻译，主要针对初学者，涵盖了从基础的`HelloWorld`示例到更高级的概念，如工作队列、发布/订阅、路由以及Topics类型交换机和远程过程调用(RPC)。教程以Java语言为例，讲解如何使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值