RabbitMQ实战

最新推荐文章于 2024-04-27 16:30:53 发布
最新推荐文章于 2024-04-27 16:30:53 发布
阅读量654 收藏
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48161661/article/details/125747841
版权

Go RabbitMQ客户端

go get github.com/streadway/amqp #原始客户端版本
go get github.com/rabbitmq/amqp091-go #最新维护版

Hello World

send.go

package main

import (
	"context"
	"log"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	q, err := ch.QueueDeclare(
		"hello", // name
		false,   // durable
		false,   // delete when unused
		false,   // exclusive
		false,   // no-wait
		nil,     // arguments
	)
	failOnError(err, "Failed to declare a queue")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	body := "Hello World!"
	err = ch.PublishWithContext(ctx,
		"",     // exchange
		q.Name, // routing key
		false,  // mandatory
		false,  // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")
	log.Printf(" [x] Sent %s\n", body)
}

receive.go

package main

import (
	"log"
	
	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	q, err := ch.QueueDeclare(
		"hello", // name
		false,   // durable
		false,   // delete when unused
		false,   // exclusive
		false,   // no-wait
		nil,     // arguments
	)
	failOnError(err, "Failed to declare a queue")

	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		for d := range msgs {
			log.Printf("Received a message: %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for messages. To exit press CTRL+C")
	<-forever
}

几个函数的注释

QueueDeclare
func (ch *Channel) QueueDeclare(name string, durable, autoDelete, exclusive, noWait bool, 
args Table) (Queue, error) {...}

-name
队列名称可能为空，在这种情况下，服务器将生成一个唯一的名称，该名称将在队列结构的名称字段中返回。

-durablel, autoDelete 
true, false
持久和非自动删除队列将在服务器重新启动后继续存在，并在没有剩余使用者或绑定时保留。
服务器重新启动时，将在此队列中恢复持久发布。
这些队列只能绑定到持久交换机上。

false, true
在服务器重新启动时，不会重新声明非持久和自动删除的队列，
并且在取消最后一个使用者或关闭最后一个消费者的通道后，服务器将在短时间内删除这些队列。
也可以使用QueueDelete正常删除具有此生存时间的队列。
这些持久队列只能绑定到非持久交换机。

false, false
只要服务器在运行，无论有多少消费者，非持久和非自动删除队列都将保持声明状态。
此生存期适用于可能在消费者活动之间具有长延迟的临时拓扑。
这些队列只能绑定到非持久交换机。

true, true
持久和自动删除的队列将在服务器重新启动时恢复，但没有活动消费者将无法生存并被删除。
这不太可能用的上。

-exclusive 
独占队列只能由声明它们的连接访问，并将在连接关闭时删除。
尝试声明、绑定、使用、清除或删除具有相同名称的队列时，其他连接上的通道将收到错误。

-noWait
当noWait为true时，队列将假定在服务器上声明。
如果满足现有队列或试图从其他连接修改现有队列的条件，则将出现通道异常。
Publish 与 PublishWithContext
func (ch *Channel) Publish(exchange, key string, mandatory, immediate bool, msg Publishing) error {...}

func (ch *Channel) PublishWithContext(ctx context.Context, exchange, key string, mandatory, 
immediate bool, msg Publishing) error {...}


Publish将Publishing从客户端发送到服务器上的exchange

当希望将单个消息传递到单个队列时，可以使用队列名称的routingKey发布到默认exchange。
这是因为每个声明的队列都有一个到默认exchange的隐式路由。

-mandatory
false：当消息无法通过交换器匹配到队列时，会丢弃消息。
true：当消息无法通过交换器匹配到队列时，会调用basic.return通知生产者。
注：不建议使用，因会使程序逻辑变得复杂，可以通过备用交换机来实现类似的功能。

-immediate
true：当消息到达Queue后，发现队列上无消费者时，通过basic.Return返回给生产者。
false：消息一直缓存在队列中，等待生产者。
注：不建议使用此参数，遇到这种情况，可用TTL和DLX方法代替

// 这里用中文注解强调几个参数
type Publishing struct {
	// Application or exchange specific fields,
	// the headers exchange will inspect this field.
	Headers Table

	// Properties
	ContentType     string    //消息的类型，通常为“text/plain”
	ContentEncoding string   //消息的编码，一般默认不用写
	DeliveryMode    uint8     //消息是否持久化，2表示持久化，0或1表示非持久化。
	Priority        uint8     //消息的优先级 0 to 9
	CorrelationId   string    // correlation identifier
	ReplyTo         string    // address to to reply to (ex: RPC)
	Expiration      string    // message expiration spec
	MessageId       string    // message identifier
	Timestamp       time.Time // message timestamp
	Type            string    // message type name
	UserId          string    // creating user id - ex: "guest"
	AppId           string    // creating application id

	// The application specific payload of the message
	Body []byte //消息主体
}

以前的Publish会自动生成一个context.Background()传入ch.PublishWithDeferredConfirmWithContext
现在的可以自定义这个ctx了
Consume

Server主动把消息推给消费者

func (ch *Channel) Consume(queue, consumer string, autoAck, exclusive, noLocal, noWait bool, 
args Table) (<-chan Delivery, error) {...}

-queue
队列名称。

-consumer
消费者标签，用于区分不同的消费者。

-autoAck
是否自动回复ACK，true为是，回复ACK表示告诉服务器我收到消息了。
建议为false，手动回复，这样可控性强。

-exclusive
设置是否排他，排他表示当前队列只能给一个消费者使用。

-noLocal
如果为true，表示生产者和消费者不能是同一个connect。

-nowait
是否非阻塞，true表示是。
阻塞：表示创建交换器的请求发送后，阻塞等待RMQ Server返回信息。
非阻塞：不会阻塞等待RMQ Server的返回信息，而RMQ Server也不会返回信息。（不推荐使用）

-args
直接写nil，没研究过

注意下返回值：返回一个<- chan Delivery类型，遍历返回值，有消息则往下走， 没有则阻塞。

Work Queues

在这里插入图片描述

task.go

go run task.go [arg]来运行，arg可以看作是要发送的消息

package main

import (
	"context"
	"log"
	"os"
	"strings"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	q, err := ch.QueueDeclare(
		"task_queue", // name
		true,         // durable
		false,        // delete when unused
		false,        // exclusive
		false,        // no-wait
		nil,          // arguments
	)
	failOnError(err, "Failed to declare a queue")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	body := bodyFrom(os.Args)
	err = ch.PublishWithContext(ctx,
		"",     // exchange
		q.Name, // routing key
		false,  // mandatory
		false,
		amqp.Publishing{
			DeliveryMode: amqp.Persistent,
			ContentType:  "text/plain",
			Body:         []byte(body),
		})
	failOnError(err, "Failed to publish a message")
	log.Printf(" [x] Sent %s", body)
}

func bodyFrom(args []string) string {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "hello"
	} else {
		s = strings.Join(args[1:], " ")
	}
	return s
}

work.go

package main

import (
	"bytes"
	"log"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	q, err := ch.QueueDeclare(
		"task_queue", // name
		true,         // durable
		false,        // delete when unused
		false,        // exclusive
		false,        // no-wait
		nil,          // arguments
	)
	failOnError(err, "Failed to declare a queue")

	//防止消息堆积，如果堆积到设置的阈值了，就不会主动向改消费者推送消息，此次轮询会跳过该消费者
	err = ch.Qos(
		1,     // prefetch count
		0,     // prefetch size
		false, // global
	)
	failOnError(err, "Failed to set QoS")

	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		false,  // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		for d := range msgs {
			log.Printf("Received a message: %s", d.Body)
			dotCount := bytes.Count(d.Body, []byte("."))
			t := time.Duration(dotCount)
			time.Sleep(t * time.Second)
			log.Printf("Done")
			d.Ack(false)
		}
	}()

	log.Printf(" [*] Waiting for messages. To exit press CTRL+C")
	<-forever
}

几个函数的注释

func (d Delivery) Ack(multiple bool) error {...}
-multiple
true表示回复当前信道所有未回复的ack，用于批量确认。
false表示回复当前条目。

func (ch *Channel) Qos(prefetchCount, prefetchSize int, global bool) error {...}
-prefetchCount
消费者未确认消息的个数。

-prefetchSize
消费者未确认消息的大小。

-global
是否全局生效，true表示是。
全局生效指的是针对当前connect里的所有channel都生效。

Publish/Subscribe

这个模式和redis的很像，一个消息给每个订阅的消费者都发一份

publish.go

package main

import (
	"context"
	"log"
	"os"
	"strings"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	err = ch.ExchangeDeclare(
		"logs",   // name
		"fanout", // 这里选择扇出
		true,     // durable
		false,    // auto-deleted
		false,    // internal
		false,    // no-wait
		nil,      // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	body := bodyFrom(os.Args)
	err = ch.PublishWithContext(ctx,
		"logs", // exchange
		"",     // routing key
		false,  // mandatory
		false,  // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")

	log.Printf(" [x] Sent %s", body)
}

func bodyFrom(args []string) string {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "hello"
	} else {
		s = strings.Join(args[1:], " ")
	}
	return s
}

subscribe.go

package main

import (
	"log"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	err = ch.ExchangeDeclare(
		"logs",   // name
		"fanout", // type
		true,     // durable
		false,    // auto-deleted
		false,    // internal
		false,    // no-wait
		nil,      // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	q, err := ch.QueueDeclare(
		"",    // 这里申请匿名队列，会自动生成uuid为名的queue
		false, // durable
		false, // delete when unused
		true,  // exclusive
		false, // no-wait
		nil,   // arguments
	)
	failOnError(err, "Failed to declare a queue")

	err = ch.QueueBind(
		q.Name, // queue name
		"",     // routing key
		"logs", // exchange
		false,
		nil,
	)
	failOnError(err, "Failed to bind a queue")

	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		for d := range msgs {
			log.Printf(" [x] %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for logs. To exit press CTRL+C")
	<-forever
}

几个函数的注释

ExchangeDeclare
func (ch *Channel) ExchangeDeclare(name, kind string, durable, autoDelete, internal, noWait bool, 
args Table) error {...}

-name
交换器的名称

-kind
也叫作type，表示交换器的类型。
有四种常用类型：direct、fanout、topic、headers。

-durable
是否持久化，true表示是。
持久化表示会把交换器的配置存盘，当RMQ Server重启后，会自动加载交换器。

-autoDelete
是否自动删除，true表示是。
至少有一条绑定才可以触发自动删除，当所有绑定都与交换器解绑后，会自动删除此交换器。

-internal
是否为内部，true表示是。
客户端无法直接发送msg到内部交换器，只有交换器可以发送msg到内部交换器。

-noWait
是否非阻塞
false表示阻塞：表示创建交换器的请求发送后，阻塞等待RMQ Server返回信息。
true表示非阻塞：不会阻塞等待RMQ Server的返回信息，而RMQ Server也不会返回信息。（不推荐使用）

func (ch *Channel) QueueBind(name, key, exchange string, noWait bool, args Table) error {...}

-name
队列名称

-key
对应图中BandingKey，表示要绑定的键。

-exchange
交换器名称

-nowait
是否非阻塞

Routing

producer.go

package main

import (
	"context"
	"log"
	"os"
	"strings"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	err = ch.ExchangeDeclare(
		"logs_direct", // name
		"direct",      // type
		true,          // durable
		false,         // auto-deleted
		false,         // internal
		false,         // no-wait
		nil,           // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	body := bodyFrom(os.Args)
	err = ch.PublishWithContext(ctx,
		"logs_direct",         // exchange
		severityFrom(os.Args), // routing key
		false,                 // mandatory
		false,                 // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")

	log.Printf(" [x] Sent %s", body)
}

func bodyFrom(args []string) string {
	var s string
	if (len(args) < 3) || os.Args[2] == "" {
		s = "hello"
	} else {
		s = strings.Join(args[2:], " ")
	}
	return s
}

func severityFrom(args []string) string {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "info"
	} else {
		s = os.Args[1]
	}
	return s
}

consumer.go

package main

import (
	"log"
	"os"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	err = ch.ExchangeDeclare(
		"logs_direct", // name
		"direct",      // type
		true,          // durable
		false,         // auto-deleted
		false,         // internal
		false,         // no-wait
		nil,           // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	q, err := ch.QueueDeclare(
		"",    // name
		false, // durable
		false, // delete when unused
		true,  // exclusive
		false, // no-wait
		nil,   // arguments
	)
	failOnError(err, "Failed to declare a queue")

	if len(os.Args) < 2 {
		log.Printf("Usage: %s [info] [warning] [error]", os.Args[0])
		os.Exit(0)
	}
	for _, s := range os.Args[1:] {
		log.Printf("Binding queue %s to exchange %s with routing key %s",
			q.Name, "logs_direct", s)
		err = ch.QueueBind(
			q.Name,        // queue name
			s,             // routing key
			"logs_direct", // exchange
			false,
			nil)
		failOnError(err, "Failed to bind a queue")
	}

	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto ack
		false,  // exclusive
		false,  // no local
		false,  // no wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		for d := range msgs {
			log.Printf(" [x] %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for logs. To exit press CTRL+C")
	<-forever
}

Topics

和上面的route一样，但是在绑定路由建的时候，有了类似于通配符的一些规则
Binding Key中的 # ：匹配任意个数的word
Binding Key中的 * ：匹配任意1个word

代码区别不大，记得在交换机的类型那改为topic

producer.go

package main

import (
        "context"
        "log"
        "os"
        "strings"
        "time"

        amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
        if err != nil {
                log.Panicf("%s: %s", msg, err)
        }
}

func main() {
        conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
        failOnError(err, "Failed to connect to RabbitMQ")
        defer conn.Close()

        ch, err := conn.Channel()
        failOnError(err, "Failed to open a channel")
        defer ch.Close()

        err = ch.ExchangeDeclare(
                "logs_topic", // name
                "topic",      // type
                true,         // durable
                false,        // auto-deleted
                false,        // internal
                false,        // no-wait
                nil,          // arguments
        )
        failOnError(err, "Failed to declare an exchange")

        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()

        body := bodyFrom(os.Args)
        err = ch.PublishWithContext(ctx,
                "logs_topic",          // exchange
                severityFrom(os.Args), // routing key
                false, // mandatory
                false, // immediate
                amqp.Publishing{
                        ContentType: "text/plain",
                        Body:        []byte(body),
                })
        failOnError(err, "Failed to publish a message")

        log.Printf(" [x] Sent %s", body)
}

func bodyFrom(args []string) string {
        var s string
        if (len(args) < 3) || os.Args[2] == "" {
                s = "hello"
        } else {
                s = strings.Join(args[2:], " ")
        }
        return s
}

func severityFrom(args []string) string {
        var s string
        if (len(args) < 2) || os.Args[1] == "" {
                s = "anonymous.info"
        } else {
                s = os.Args[1]
        }
        return s
}

consumer.go

package main

import (
        "log"
        "os"

        amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
        if err != nil {
                log.Panicf("%s: %s", msg, err)
        }
}

func main() {
        conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
        failOnError(err, "Failed to connect to RabbitMQ")
        defer conn.Close()

        ch, err := conn.Channel()
        failOnError(err, "Failed to open a channel")
        defer ch.Close()

        err = ch.ExchangeDeclare(
                "logs_topic", // name
                "topic",      // type
                true,         // durable
                false,        // auto-deleted
                false,        // internal
                false,        // no-wait
                nil,          // arguments
        )
        failOnError(err, "Failed to declare an exchange")

        q, err := ch.QueueDeclare(
                "",    // name
                false, // durable
                false, // delete when unused
                true,  // exclusive
                false, // no-wait
                nil,   // arguments
        )
        failOnError(err, "Failed to declare a queue")

        if len(os.Args) < 2 {
                log.Printf("Usage: %s [binding_key]...", os.Args[0])
                os.Exit(0)
        }
        for _, s := range os.Args[1:] {
                log.Printf("Binding queue %s to exchange %s with routing key %s",
                        q.Name, "logs_topic", s)
                err = ch.QueueBind(
                        q.Name,       // queue name
                        s,            // routing key
                        "logs_topic", // exchange
                        false,
                        nil)
                failOnError(err, "Failed to bind a queue")
        }

        msgs, err := ch.Consume(
                q.Name, // queue
                "",     // consumer
                true,   // auto ack
                false,  // exclusive
                false,  // no local
                false,  // no wait
                nil,    // args
        )
        failOnError(err, "Failed to register a consumer")

        var forever chan struct{}

        go func() {
                for d := range msgs {
                        log.Printf(" [x] %s", d.Body)
                }
        }()

        log.Printf(" [*] Waiting for logs. To exit press CTRL+C")
        <-forever
}
离异脖士孙亚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ实战视频.zip
03-19
对于消息中间件，目前在企业级应用以及微服务应用跟分布式系统应用还是相当广泛的，但是有时候有些童鞋苦于没有入门以及实战的视频教程指导而磕磕碰碰了许久。在此，我精心录制的这一套视频教程将几乎手把手指导大家入门学习RabbitMQ并将所学的知识要点实战到实际的业务场景中，特别是在第二阶段的学习，将采用SpringBoot整合RabbitMQ的方式来实战实际的业务场景，并用来解决微服务项目以及分布式系统中常见的典型问题，比如服务模块异步解耦、延迟监听消费处理、秒杀系统高并发方案的解决、限流以及死信队列的应用等等。
RabbitMQ实战教程
06-10
本课程适用于RabbitMQ实战者以及SpringBoot整合RabbitMQ实战需求者。课程将首先带领大家拜读RabbitMQ官网的技术开发手册，之后会将学到的知识深入的实战到实际的各种应用场景中，从而加深知识点的理解，其中包括如何实现单一队列多个消费者监听消费、业务服务模块解耦通信、抢单高并发方案的解决、登录成功异步写日志、异步发送邮件、死信队列实战以及实现用户下单超时未支付自动失效等等。
RabbitMQ实战指南.7z
11-30
RabbitMQ 是目前非常热门的一款消息中间件，不管是互联网行业还是传统行业都在大量 地使用 RabbitMQ 凭借其高可靠、易扩展、高可用及丰富的功能特性受到越来越多企业的青 作为一个合格的开发者，有必要深入地了解 RabbitMQ 的相关知识，为自己的职业生涯添 砖加瓦
rabbitMQ实战
10-10
这是牧码人王老师讲的，里面的rabbitMQ下载、安装、六种消息类型都很全，代码我也都试过了，直接复制粘贴就可以使用，希望可以帮助到大家
rabbitMq实战
02-27
RabbiMQ消息队列的介绍和在各个场景下的使用
go-amqp-reconnect:github.comstreadwayamqp连接和通道的自动重新连接示例
05-07
streadway / amqp连接/通道自动重新连接包装 如果rabbitmq服务器重新启动/关闭，则streadway / amqp连接/通道不会重新连接。 对于简单的开发人员，这里是带有详细注释的自动重新连接包装。 如何更改现有代码 添加导入import "github.com/isayme/go-amqp-reconnect/rabbitmq" 更换amqp.Connection / amqp.Channel与rabbitmq.Connection / rabbitmq.Channel ！ 例子 被开发者关闭 去运行example / close / demo.go 自动重新连接 去运行example / reconnect / demo.go
【Golang版】RabbitMQ 6种工作模式示例
深漂小码哥
08-15 772
go get github.com/rabbitmq/amqp091-go 1.Hello World 2.工作队列模式 3.发布/订阅模式 4.路由模式 5.主题模式 6.RPC模式
GO 操作RabbitMQ
weixin_42562106的博客
01-06 1734
docker快速安装mq docker run -d --hostname my-rabbit --name some-rabbit -e RABBITMQ_DEFAULT_USER=admins -e RABBITMQ_DEFAULT_PASS=123qwe123 -p15672:15672 -p5672:5672 rabbitmq:management-alpine go 需要安装 go get github.com/streadway/amqp 生产者代码send.go package main
分享一个极好的go练手小项目，可以综合应用高并发服务的许多知识点。
ckw1988的专栏
04-20 282
客户端在发送请求前，注册一个随机名称的队列，用以接收计算结果的返回值（以下简称回应队列），该队列名会在发送计算请求到“rpc_queue”时附带在请求信息的“ReplyTo”属性中，而服务端在计算完毕后向该队列名发送计算结果即可。接下来找到客户端代码的fibonacciRPC方法的定义位置，该方法即rpc方法的本体，方法中包含了发送请求到rpc服务、阻塞线程以等待返回、获取返回结果后return给方法调用者等三个步骤，对外表现即为一个同步调用方法。我自己完成的demo再稍做修饰，过会儿上传。
rabbitmq实战指南
04-16
rabbitmq消息队列，同时epub格式也支持各种软件设备。
用于支持自动重新连接的staway / amqp的RabbitMQ包装器-Golang开发
05-26
用于支持自动重新连接兔子的steadway / amqp的RabbitMQ包装器RabbitMQ包装器lib在streadway / amqp周围带有一些铃铛。 支持自动重新连接支持上下文（即取消/超时）？？？ 动机我们（批次）大量使用RabbitMQ-我们将其用作促进服务间通信的主要方法。 因此，所有服务都使用RabbitMQ，并且既是发布者又是消费者。 我们编写此库是为了确保我们所有的服务都以一致，可预测的方式使用Rabbit，并且能够
RabbitMQ实战资源
11-13
RabbitMQ实战demo，工作模式，RabbitMQ问题解决方案
RabbitMQ实战： 高效部署分布式消息队列.pdf
08-31
RabbitMQ实战： 高效部署分布式消息队列,高质量文档分享，请珍惜！
RabbitMQ-死信队列
最新发布
m0_74356429的博客
04-27 271
1、什么是死信在 RabbitMQ 中充当主角的就是消息，在不同场景下，消息会有不同地表现。死信就是消息在特定场景下的一种表现形式，这些场景包括：1. 消息被拒绝访问，即 RabbitMQ返回 basicNack 的信号时 或者拒绝basicRejectbasicNack3. 消息的过期时长或。4. 消息队列达到最大容量上述场景经常产生死信，即消息在这些场景中时，被称为死信。2、什么是死信队列死信队列就是用于储存死信的消息队列，在死信队列中，有且只有死信构成，不会存在其余类型的消息。
RabbitMQ在Java中的完美实现：从入门到精通
木头大左的博客
04-23 593
RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。本文将详细介绍如何在Java项目中使用RabbitMQ。
不重启服务 动态停止、启动RabbitMQ消费者 监听器
熊孩子的博客
04-23 450
不重启服务 动态停止、启动RabbitMQ消费者 监听器
RabbitMQ中的交换机类型
qq_64064246的博客
04-26 590
另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！不过队列一定要与交换机绑定。消息的发送方在 向 Exchange发送消息时，也必须指定消息的。Exchange不再把消息交给每一个绑定的队列，而是根据消息的。队列与交换机的绑定，不能是任意绑定了，而是要指定一个。
什么是RabbitMQ，RabbitMQ基本概念，RabbitMQ的使用场景
小小鱼儿小小林的博客
04-25 457
RabbitMQ是一个开源的消息代理软件（也称为消息队列），它实现了高级消息队列协议（AMQP）。RabbitMQ提供了一种应用程序对应用程序之间的通信方法，基于消费-生产者模型，允许分布式系统中的组件进行异步通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值