0%

先决条件
本教程假定 RabbitMQ 已经安装,并运行在localhost 标准端口(5672)。如果你使用不同的主机、端口或证书,则需要调整连接设置。

从哪里获得帮助
如果您在阅读本教程时遇到困难,可以通过邮件列表 联系我们

路由#

(使用.NET客户端)

教程[3] 中,我们构建了一个简单的日志系统,可以向多个接收者广播消息。

在本教程中,我们会为日志系统再添加一个特性,使其可以只订阅消息的一个子集。例如,将所有日志消息打印到
控制台,同时只会将严重错误消息写入日志文件(保存到磁盘空间)。

绑定#

在前面的例子中,我们创建过_绑定_。不知道您是否还记得下面的代码:

channel.QueueBind(queue: queueName,
                  exchange: "logs",
                  routingKey: "");

绑定是指交换器和队列之间的关联关系。可以简单地理解为:某个队列对来自此交换器的消息感兴趣。

绑定可以采用额外的routingKey参数,为了避免与BasicPublish方法中相同参数混淆,我们将其称为binding key(这里是指路由键从声明角度的一种别称,绑定键)。下面即是如何使用绑定键 建立一个绑定:

channel.QueueBind(queue: queueName,
                  exchange: "direct_logs",
                  routingKey: "black");

绑定键的含义取决于交换器类型。像我们前面使用的fanout 交换器,忽略了它的值(依据fanout交换器的特性,它会把消息广播到所有订阅的队列,所以就算指定routingKey也不会根据其过滤消息)。

Direct交换器#

在上篇教程中,我们的日志系统会把所有消息广播给所有消费者,现在我们想要扩展使其可以根据消息的严重性过滤消息。例如,我们希望将日志消息写入磁盘的脚本仅接收严重错误的消息,而不是在警告或者信息类型的消息上浪费磁盘空间。

之前我们使用的是fanout交换器,它没有给我们足够的灵活性 - 它只能进行无意识的广播。

现在我们要用direct交换器替换它,direct交换器背后的路由算法很简单 - 消息会进入其binding key恰好与routing key相匹配的队列。
为了说明这一点,请参考以下设置:

在上面的设置中,我们可以看到direct交换器X与两个队列绑定。第一个队列通过键orange绑定,第二个队列有两个绑定,一个通过键black绑定、另外一个通过键green绑定。

如此设置,发布使用路由键orange的消息到交换器最终会被路由到队列Q1,路由键为blackgreen的消息会去向队列Q2,而其他所有的消息会被丢弃。

多重绑定#

使用相同的绑定键绑定多个队列是完全合法的。在示例中,我们可以在XQ1之间添加一个键为black的绑定。这种情况下,direct交换器会像fanout交换器一样,把消息广播到所有匹配的队列,路由键为black的消息会被分别发送到队列Q1Q2

发送日志#

我们将在日志系统中使用上述消息模型,在发送消息时使用direct交换机来替换fanout交换器。同时我们会把日志的严重性作为路由键,这样的话,接收脚本就可以选择性地接收它期望严重性的消息。首先我们来关注如何发送日志。

同样地,我们需要先创建一个交换器:

channel.ExchangeDeclare(exchange: "direct_logs", type: ExchangeType.Direct);

准备好发送消息:

var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "direct_logs",
                     routingKey: severity,
                     basicProperties: null,
                     body: body);

简单起见,我们先假定severity可以是infowarningerror任意一值。

订阅#

马上就可以像前面的教程接收消息了,但有一点不同, 我们需要为我们感兴趣的每种日志严重性级别的消息建立一个新的绑定。

var queueName = channel.QueueDeclare().QueueName;

foreach(var severity in args)
{
    channel.QueueBind(queue: queueName,
                      exchange: "direct_logs",
                      routingKey: severity);
}

组合在一起#

EmitLogDirect.cs类的代码:

using System;
using System.Linq;
using RabbitMQ.Client;
using System.Text;

class EmitLogDirect
{
    public static void Main(string[] args)
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.ExchangeDeclare(exchange: "direct_logs",
                                    type: "direct");

            var severity = (args.Length > 0) ? args[0] : "info";
            var message = (args.Length > 1)
                          ? string.Join(" ", args.Skip(1).ToArray())
                          : "Hello World!";
            var body = Encoding.UTF8.GetBytes(message);
            channel.BasicPublish(exchange: "direct_logs",
                                 routingKey: severity,
                                 basicProperties: null,
                                 body: body);
            Console.WriteLine(" [x] Sent '{0}':'{1}'", severity, message);
        }

        Console.WriteLine(" Press [enter] to exit.");
        Console.ReadLine();
    }
}

ReceiveLogsDirect.cs类的代码:

using System;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System.Text;

class ReceiveLogsDirect
{
    public static void Main(string[] args)
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.ExchangeDeclare(exchange: "direct_logs",
                                    type: "direct");
            var queueName = channel.QueueDeclare().QueueName;

            if(args.Length < 1)
            {
                Console.Error.WriteLine("Usage: {0} [info] [warning] [error]",
                                        Environment.GetCommandLineArgs()[0]);
                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
                Environment.ExitCode = 1;
                return;
            }

            foreach(var severity in args)
            {
                channel.QueueBind(queue: queueName,
                                  exchange: "direct_logs",
                                  routingKey: severity);
            }

            Console.WriteLine(" [*] Waiting for messages.");

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body;
                var message = Encoding.UTF8.GetString(body);
                var routingKey = ea.RoutingKey;
                Console.WriteLine(" [x] Received '{0}':'{1}'",
                                  routingKey, message);
            };
            channel.BasicConsume(queue: queueName,
                                 autoAck: true,
                                 consumer: consumer);

            Console.WriteLine(" Press [enter] to exit.");
            Console.ReadLine();
        }
    }
}

请像往常一样创建项目(请参阅 教程[1])。

如果您想将warningerror(不包括info)日志消息保存到文件,只需打开控制台并输入:

cd ReceiveLogsDirect
dotnet run warning error > logs_from_rabbit.log

如果您想在屏幕上看到所有日志消息,请打开一个新终端并执行以下操作:

cd ReceiveLogsDirect
dotnet run info warning error

例如,想要发出error日志消息,只需要输入:

cd EmitLogDirect
dotnet run error "Run. Run. Or it will explode."

EmitLogDirect.csReceiveLogsDirect.cs 的完整源代码。

跳转到 教程[5],了解如何基于模式监听消息。

写在最后#

本文翻译自 RabbitMQ 官方教程 C# 版本。如本文介绍内容与官方有所出入,请以官方最新内容为准。水平有限,翻译的不好请见谅,如有翻译错误还请指正。

  • 原文链接:RabbitMQ tutorial - Routing
  • 实验环境:RabbitMQ 3.7.4 、.NET Core 2.1.3、Visual Studio Code
  • 最后更新:2018-08-31

先决条件
本教程假定 RabbitMQ 已经安装,并运行在localhost 标准端口(5672)。如果你使用不同的主机、端口或证书,则需要调整连接设置。

从哪里获得帮助
如果您在阅读本教程时遇到困难,可以通过邮件列表 联系我们

工作队列#

(使用 .NET Client)

教程[1] 中,我们编写了两个程序,用于从一个指定的队列发送和接收消息。在本文中,我们将创建一个_工作队列_,用于在多个工作线程间分发耗时的任务。

工作队列(又名:任务队列)背后的主要想法是避免立即执行资源密集型、且必须等待其完成的任务。相反的,我们把这些任务安排在稍后完成。我们可以将任务封装为消息并把它发送到队列中,在后台运行的工作进程将从队列中取出任务并最终执行。当您运行多个工作线程,这些任务将在这些工作线程之间共享。

这个概念在Web应用程序中特别有用,因为在一个 HTTP 请求窗口中无法处理复杂的任务。

准备#

我们将略微修改上一个示例中的_Send_程序,以其可以在命令行发送任意消息。
这个程序将调度任务到我们的工作队列中,所以让我们把它命名为NewTask

教程[1]一样,我们需要生成两个项目:

dotnet new console --name NewTask
mv NewTask/Program.cs NewTask/NewTask.cs

dotnet new console --name Worker
mv Worker/Program.cs Worker/Worker.cs

cd NewTask
dotnet add package RabbitMQ.Client
dotnet restore

cd ../Worker
dotnet add package RabbitMQ.Client
dotnet restore


var message = GetMessage(args);
var body = Encoding.UTF8.GetBytes(message);

var properties = channel.CreateBasicProperties();
properties.Persistent = true;

channel.BasicPublish(exchange: "",
                     routingKey: "task_queue",
                     basicProperties: properties,
                     body: body);

从命令行参数获取消息的帮助方法:

private static string GetMessage(string[] args)
{
    return ((args.Length > 0) ? string.Join(" ", args) : "Hello World!");
}

我们旧的Receive.cs脚本也需要进行一些更改:它需要为消息体中的每个点模拟一秒种的时间消耗。它将处理由 RabbitMQ 发布的消息,并执行任务,因此我们把它复制到Worker项目并修改:

var consumer = new EventingBasicConsumer(channel);


​ consumer.Received += (model, ea) =>
​ {
​ var body = ea.Body;
​ var message = Encoding.UTF8.GetString(body);
​ Console.WriteLine(“ [x] Received {0}”, message);


​ int dots = message.Split(‘.’).Length - 1;
​ Thread.Sleep(dots * 1000);

​ Console.WriteLine(“ [x] Done”);
​ };

channel.BasicConsume(queue: “task_queue”, autoAck: true, consumer: consumer);

模拟虚拟任务的执行时间:

int dots = message.Split('.').Length - 1;
Thread.Sleep(dots * 1000);

循环调度#

使用任务队列的优点之一是能够轻松地并行工作。如果我们正在积累积压的工作,我们仅要增加更多的工作者,并以此方式可以轻松扩展。

首先,我们尝试同时运行两个Worker实例。他们都会从队列中获取消息,但究竟如何?让我们来看看。

您需要打开三个控制台,两个运行Worker程序,这些控制台作为我们的两个消费者 - C1和C2。

cd Worker
dotnet run

cd Worker
dotnet run

在第三个控制台中,我们将发布一些新的任务。一旦你已经运行了消费者,你可以尝试发布几条消息:

cd NewTask
dotnet run "First message."
dotnet run "Second message.."
dotnet run "Third message..."
dotnet run "Fourth message...."
dotnet run "Fifth message....."

让我们看看有什么发送到了我们的Worker程序:

# shell 1
# => [*] Waiting for messages. To exit press CTRL+C
# => [x] Received 'First message.'
# => [x] Received 'Third message...'
# => [x] Received 'Fifth message.....'


# shell 2
# => [*] Waiting for messages. To exit press CTRL+C
# => [x] Received 'Second message..'
# => [x] Received 'Fourth message....'

默认情况下,RabbitMQ 会按顺序将每条消息发送给下一个消费者。消费者数量平均的情况下,每个消费者将会获得相同数量的消息。这种分配消息的方式称为循环(Round-Robin)。请尝试开启三个或更多的Worker程序来验证。

消息确认#

处理一项任务可能会需要几秒钟的时间。如果其中一个消费者开启了一项长期的任务并且只完成了部分就挂掉了,您可能想知道会发生什么?在我们当前的代码中,一旦 RabbitMQ 把消息分发给了消费者,它会立即将这条消息标记为删除。在这种情况下,如果您停掉某一个 Worker,我们将会丢失这条正在处理的消息,也将丢失所有分发到该 Worker 但尚未处理的消息。

但是我们不想丢失任何一个任务。如果一个 Worker 挂掉了,我们希望这个任务能被重新分发给其他 Worker。

为了确保消息永远不会丢失,RabbitMQ 支持 消息确认 机制。消费者回发一个确认信号 Ack(nowledgement) 给 RabbitMQ,告诉它某个消息已经被接收、处理并且可以自由删除它。

如果一个消费者在还没有回发确认信号之前就挂了(其通道关闭,连接关闭或者 TCP 连接丢失),RabbitMQ 会认为该消息未被完全处理,并将其重新排队。如果有其他消费者同时在线,该消息将会被会迅速重新分发给其他消费者。这样,即便 Worker 意外挂掉,也可以确保消息不会丢失。

没有任何消息会超时;当消费者死亡时,RabbitMQ 将会重新分发消息。即使处理消息需要非常非常长的时间也没关系。

默认情况下,手动消息确认 模式是开启的。在前面的例子中,我们通过将autoAck(“自动确认模式”)参数设置为true来明确地关闭手动消息确认模式。一旦完成任务,是时候删除这个标志并且从 Worker 手动发送一个恰当的确认信号给RabbitMQ。

var consumer = new EventingBasicConsumer(channel);


​ consumer.Received += (model, ea) =>
​ {
​ var body = ea.Body;
​ var message = Encoding.UTF8.GetString(body);
​ Console.WriteLine(“ [x] Received {0}”, message);


​ int dots = message.Split(‘.’).Length - 1;
​ Thread.Sleep(dots * 1000);

​ Console.WriteLine(“ [x] Done”);


​ channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
​ };



​ channel.BasicConsume(queue: “task_queue”, autoAck: false, consumer: consumer);

使用上面这段代码,我们可以确定的是,即使一个 Worker 在处理消息时,我们通过使用CTRL + C来终止它,也不会丢失任何消息。Worker 挂掉不久,所有未确认的消息将会被重新分发。

忘记确认
遗漏BasicAck是一个常见的错误。这是一个很简单的错误,但导致的后果却是严重的。当客户端退出时(看起来像是随机分发的),消息将会被重新分发,但是RabbitMQ会吃掉越来越多的内存,因为它不能释放未确认的消息。
为了调试这种错误,您可以使用rabbitmqctl来打印messages_unacknowledged字段:

sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged

在Windows上,删除sudo

rabbitmqctl.bat list_queues name messages_ready messages_unacknowledged

消息持久化#

我们已经学习了如何确保即使消费者挂掉,任务也不会丢失。但是如果 RabbitMQ 服务器停止,我们的任务还是会丢失。

当 RabbitMQ 退出或崩溃时,它会忘记已存在的队列和消息,除非告诉它不要这样做。为了确保消息不会丢失,有两件事是必须的:我们需要将队列和消息标记为持久

首先,我们需要确保 RabbitMQ 永远不会丢失我们的队列。为了做到这一点,我们需要把队列声明是_持久的(Durable)_:

// 声明队列,通过指定 durable 参数为 true,对消息进行持久化处理。 
channel.QueueDeclare(queue: "hello",
                     durable: true,
                     exclusive: false,
                     autoDelete: false,
                     arguments: null);

虽然这个命令本身是正确的,但是它在当前设置中不会起作用。那是因为我们已经定义过一个名为hello的队列,并且这个队列不是持久化的。RabbitMQ 不允许使用不同的参数重新定义已经存在的队列,并会向尝试执行该操作的程序返回一个错误。但有一个快速的解决办法 - 让我们用不同的名称声明一个队列,例如task_queue

channel.QueueDeclare(queue: "task_queue",
                     durable: true,
                     exclusive: false,
                     autoDelete: false,
                     arguments: null);

注意,该声明队列QueueDeclare方法的更改需要同时应用于生产者和消费者代码。

此时,我们可以确定的是,即使 RabbitMQ 重新启动,task_queue队列也不会丢失。现在我们需要将我们的消息标记为_持久的(Persistent)_ - 通过将IBasicProperties.Persistent设置为true

var properties = channel.CreateBasicProperties();
properties.Persistent = true;

关于消息持久性的说明
将消息标记为Persistent并不能完全保证消息不会丢失。尽管它告诉 RabbitMQ 将消息保存到磁盘,但当 RabbitMQ 接收到消息并且尚未保存消息时仍有一段时间间隔。此外,RabbitMQ 不会为每条消息执行fsync(2) - 它可能只是保存到缓存中,并没有真正写入磁盘。消息的持久化保证并不健壮,但对于简单的任务队列来说已经足够了。如果您需要一个更加健壮的保证,可以使用 发布者确认

公平调度#

您可能已经注意到调度仍然无法完全按照我们期望的方式工作。例如,在有两个 Worker 的情况下,假设所有奇数消息都很庞大、偶数消息都很轻量,那么一个 Worker 将会一直忙碌,而另一个 Worker 几乎不做任何工作。是的,RabbitMQ 并不知道存在这种情况,它仍然会平均地分发消息。

发生这种情况是因为 RabbitMQ 只是在消息进入队列后就将其分发。它不会去检查每个消费者所拥有的未确认消息的数量。它只是盲目地将第 n 条消息分发给第 n 位消费者。

为了改变上述这种行为,我们可以使用参数设置prefetchCount = 1basicQos方法。

这就告诉 RabbitMQ 同一时间不要给一个 Worker 发送多条消息。或者换句话说,不要向一个 Worker 发送新的消息,直到它处理并确认了前一个消息。
相反,它会这个消息调度给下一个不忙碌的 Worker。

channel.BasicQos(0, 1, false);

关于队列大小的说明
如果所有的 Worker 都很忙,您的队列可能会被填满。请留意这一点,可以尝试添加更多的 Worker,或者使用其他策略。

组合在一起#

我们NewTask.cs类的最终代码:

using System;
using RabbitMQ.Client;
using System.Text;

class NewTask
{
    public static void Main(string[] args)
    {
        
        var factory = new ConnectionFactory() { HostName = "localhost" };


​ using(var connection = factory.CreateConnection())
​ using(var channel = connection.CreateModel())
​ {

​ channel.QueueDeclare(queue: “task_queue”,
​ durable: true,
​ exclusive: false,
​ autoDelete: false,
​ arguments: null);


​ var message = GetMessage(args);
​ var body = Encoding.UTF8.GetBytes(message);


​ var properties = channel.CreateBasicProperties();
​ properties.Persistent = true;


​ channel.BasicPublish(exchange: “”,
​ routingKey: “task_queue”,
​ basicProperties: properties,
​ body: body);

​ Console.WriteLine(“ [x] Sent {0}”, message);
​ }

Console.WriteLine(“ Press [enter] to exit.”);
Console.ReadLine();
}

    private static string GetMessage(string[] args)
    {
        return ((args.Length > 0) ? string.Join(" ", args) : "Hello World!");
    }
}

(NewTask.cs 源码)

还有我们的Worker.cs

using System;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System.Text;
using System.Threading;

class Worker
{
    public static void Main()
    {
        
        var factory = new ConnectionFactory() { HostName = "localhost" };


​ using(var connection = factory.CreateConnection())
​ using(var channel = connection.CreateModel())
​ {

​ channel.QueueDeclare(queue: “task_queue”,
​ durable: true,
​ exclusive: false,
​ autoDelete: false,
​ arguments: null);


​ channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);

​ Console.WriteLine(“ [*] Waiting for messages.”);


​ var consumer = new EventingBasicConsumer(channel);


​ consumer.Received += (model, ea) =>
​ {
​ var body = ea.Body;
​ var message = Encoding.UTF8.GetString(body);
​ Console.WriteLine(“ [x] Received {0}”, message);


​ int dots = message.Split(‘.’).Length - 1;
​ Thread.Sleep(dots * 1000);

​ Console.WriteLine(“ [x] Done”);


​ channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
​ };

​ channel.BasicConsume(queue: “task_queue”,
​ autoAck: false,
​ consumer: consumer);

Console.WriteLine(“ Press [enter] to exit.”);
Console.ReadLine();
}
}
}

(Worker.cs 源码)

使用消息确认机制和BasicQ您可以创建一个工作队列。即使 RabbitMQ 重新启动,通过持久性选项也可让任务继续存在。

有关IModel方法和IBasicProperties的更多信息,您可以在线浏览 RabbitMQ .NET客户端API参考

现在,我们可以继续阅读 教程[3],学习如何向多个消费者发送相同的消息。

写在最后#

本文翻译自 RabbitMQ 官方教程 C# 版本。如本文介绍内容与官方有所出入,请以官方最新内容为准。水平有限,翻译的不好请见谅,如有翻译错误还请指正。

先决条件
本教程假定 RabbitMQ 已经安装,并运行在localhost 标准端口(5672)。如果你使用不同的主机、端口或证书,则需要调整连接设置。

从哪里获得帮助
如果您在阅读本教程时遇到困难,可以通过邮件列表 联系我们

发布/订阅#

(使用 .NET Client)

教程[2] 中,我们创建了一个工作队列,假设在工作队列中的每一个任务都只被分发给一个 Worker。那么在这一章节,我们要做与之完全不同的事,那就是我们将要把一条消息分发给多个消费者。这种模式被称为“发布/订阅”。

为了说明、体现这种模式,我们将会建一个简单的日志系统。它将会包含两个程序 - 第一个用来发送日志消息,第二个用来接收并打印它们。

在我们建立的日志系统中,每个接收程序的运行副本都会收到消息。这样我们就可以运行一个接收程序接收消息并将日志写入磁盘;同时运行另外一个接收程序接收消息并将日志打印到屏幕上。

实质上,发布的日志消息将会被广播给所有的接收者。

交换器#

在教程的前几部分,我们是发送消息到队列并从队列中接收消息。现在是时候介绍 Rabbit 中完整的消息传递模型了。

让我们快速回顾一下前面教程中的内容:

  • _生产者_是发送消息的用户应用程序。
  • _队列_是存储消息的缓冲区。
  • _消费者_是接收消息的用户应用程序。

在 RabbitMQ 中,消息传递模型的核心理念是生产者从来不会把任何消息直接发送到队列,其实,通常生产者甚至不知道消息是否会被分发到任何队列中。

然而,生产者只能把消息发送给_交换器_。交换器非常简单,一方面它接收来自生产者的消息,另一方面又会把接收的消息推送到队列中。交换器必须明确知道该如何处理收到的消息,应该追加到一个特定队列中?还是应该追加到多个队列中?或者应该把它丢弃?这些规则都被定义在_交换器类型_中。

Exchanges

目前交换器类型有这几种:directtopicheadersfanout。我们先重点关注最后一个fanout,我们创建一个这种类型的交换器,将其命名为logs

channel.ExchangeDeclare("logs", "fanout");

fanout类型交换器非常简单,正如您可能从名字中猜出的那样,它会把收到的所有消息广播到它已知的所有队列中。这恰巧是我们的日志系统目前所需要的。

列举交换器
要列举出服务器上的交换器,您可以使用非常有用的rabbitmqctl命令行工具:

sudo rabbitmqctl list_exchanges

执行上述命令后,出现的列表中将会有一些amq.*交换器和默认(未命名)交换器。这些是默认创建的,不过目前您可能用不到它们。

默认交换器
在教程的前些部分,我们对交换器这一概念还一无所知,但仍然可以把消息发送到队列。之所以这样,是因为我们使用了一个用空字符串("")标识的默认交换器。

回顾一下我们之前如何发布消息:

var message = GetMessage(args);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "",
                     routingKey: "hello",
                     basicProperties: null,
                     body: body);

第一个参数就是交换器的名称,空字符串表示默认或匿名交换器:将消息路由到routingKey指定的队列(如果存在)中。

现在,我们可以把消息发布到我们指定的交换器:

var message = GetMessage(args);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "logs",
                     routingKey: "",
                     basicProperties: null,
                     body: body);

临时队列#

您是否还记得之前我们使用过的队列,它们都有一个特定的名称(记得应该是hellotask_queue吧)。给队列命名对我们来说是至关重要的 – 因为我们可能需要多个 Worker 指向同一个队列;当您想要在生产者和消费者之间共享队列时,给队列一个名称也是非常重要的。

但是,我们创建的日志系统并不希望如此。我们希望监听所有的日志消息,而不仅仅是其中一部分。我们也只对目前流动的消息感兴趣,而不是旧消息。为解决这个问题,我们需要做好两件事。

首先,我们无论何时连接 Rabbit,都需要一个新的、空的队列。要做到这一点,我们可以使用随机名称来创建队列,或许,甚至更好的方案是让服务器为我们选择一个随机队列名称。

其次,一旦我们与消费者断开连接,与之相关的队列应该被自动删除。

在 .NET 客户端中,如果不向QueueDeclare()方法提供任何参数,实际上就是创建了一个非持久化、独占、且自动删除的随机命名队列:

var queueName = channel.QueueDeclare().QueueName;

您可以在 队列指南 中了解更多关于exclusive参数和其他队列属性的信息。

此时,queueName包含一个随机队列名称。例如,它看起来可能像amq.gen-JzTY20BRgKO-HjmUJj0wLg

绑定#

Bindings

我们已经创建好了一个fanout 交换器和一个队列。现在我们需要告诉交换器把消息发送到我们的队列。而交换器和队列之间的关系就称之为_绑定_。

channel.QueueBind(queue: queueName,
                  exchange: "logs",
                  routingKey: "");

从现在起,logs交换器会把消息追加到我们的队列中。

列举绑定
您可以使用(您或许已经猜到了),列举出现有的绑定。

sudo rabbitmqctl list_bindings

组合在一起#

生产者程序负责分发消息,这与之前的教程看起来没有太大区别。

最重要的变化是我们现在想把消息发布到我们的logs交换器,而不是匿名交换器。在发送时我们需要提供一个路由键routingKey,但是对于fanout交换器,它的值可以被忽略。这里是EmitLog.cs文件的代码:

using System;
using RabbitMQ.Client;
using System.Text;

class EmitLog
{
    public static void Main(string[] args)
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.ExchangeDeclare(exchange: "logs", type: "fanout");

            var message = GetMessage(args);
            var body = Encoding.UTF8.GetBytes(message);
            channel.BasicPublish(exchange: "logs",
                                 routingKey: "",
                                 basicProperties: null,
                                 body: body);
            Console.WriteLine(" [x] Sent {0}", message);
        }

        Console.WriteLine(" Press [enter] to exit.");
        Console.ReadLine();
    }

    private static string GetMessage(string[] args)
    {
        return ((args.Length > 0)
               ? string.Join(" ", args)
               : "info: Hello World!");
    }
}

EmitLog.cs 源码)

如你所见,在建立连接后,我们声明了交换器。这一步非常有必要,因为发布消息到一个不存在的交换器,这种情况是被禁止的。

如果没有队列绑定到交换器上,消息将会丢失,但这对我们来说并没有什么没问题;如果没有消费者正在监听,我们是可以放心地把消息丢弃的。

ReceiveLogs.cs的代码:

using System;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System.Text;

class ReceiveLogs
{
    public static void Main()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.ExchangeDeclare(exchange: "logs", type: "fanout");

            var queueName = channel.QueueDeclare().QueueName;
            channel.QueueBind(queue: queueName,
                              exchange: "logs",
                              routingKey: "");

            Console.WriteLine(" [*] Waiting for logs.");

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body;
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine(" [x] {0}", message);
            };
            channel.BasicConsume(queue: queueName,
                                 autoAck: true,
                                 consumer: consumer);

            Console.WriteLine(" Press [enter] to exit.");
            Console.ReadLine();
        }
    }
}

ReceiveLogs.cs 源码)

按照 教程[1]中的设置说明生成EmitLogsReceiveLogs 项目。

如果您想把日志保存到文件中,只需打开一个控制台并输入:

cd ReceiveLogs
dotnet run > logs_from_rabbit.log

如果你想在屏幕上看到日志,我可以新开一个终端并运行:

cd ReceiveLogs
dotnet run

当然,分发日志需要输入:

cd EmitLog
dotnet run

使用rabbitmqctl list_bindings命令,您可以验证代码是否真正创建了我们想要的绑定和队列。当有两个ReceiveLogs.cs程序运行时,您应该看到如下所示的内容:

sudo rabbitmqctl list_bindings




对执行结果的解释简洁明了:来自logs交换器的数据转发到了两个由服务器随机分配名称的队列。这正是我们期待的结果。

想要了解如何监听消息的这一块内容,让我们继续阅读 教程[4]

写在最后#

本文翻译自 RabbitMQ 官方教程 C# 版本。如本文介绍内容与官方有所出入,请以官方最新内容为准。水平有限,翻译的不好请见谅,如有翻译错误还请指正。

先决条件
本教程假定 RabbitMQ 已经安装,并运行在localhost 标准端口(5672)。如果你使用不同的主机、端口或证书,则需要调整连接设置。

从哪里获得帮助
如果您在阅读本教程时遇到困难,可以通过邮件列表 联系我们

介绍#

RabbitMQ 是一个消息中间件:它接收并转发消息。您可以把它想象为一个邮局:当您把需要寄出的邮件投递到邮箱,邮差最终会把邮件送给您的收件人。在这个比喻中,RabbitMQ 就是一个邮箱,也可以理解成邮局和邮递员。

RabbitMQ 和邮局的主要区别在于它不处理纸张,而是接收、存储和转发二进制数据块 - _消息_。

RabbitMQ 和消息传递通常使用一些术语。

生产 的意思无非就是发送。发送消息的程序就是一个 _生产者_:

Producer

队列 就是 RabbitMQ 内部“邮箱”的名称。虽然消息流经 RabbitMQ 和您的应用程序,但它们只能存储在 队列 中。_队列_ 只受主机的内存和磁盘的限制,它本质上就是一个很大的消息缓冲区。多个 生产者 可以发送消息到一个队列,并且多个 消费者 可以尝试从一个 队列 接收数据。这就是我们代表队列的方式:

Queue

消费 与接收有相似的含义,等待接收消息的程序就是一个 _消费者_:

Consumer

注意:生产者、消费者和中间件不是必须部署在同一主机上,实际上在大多数应用程序中它们也不是这样的。

“Hello World”#

使用 .NET / C#Client

在教程的这一部分,我们将用 C# 编写两个程序:一个发送单条消息的生产者,以及接收消息并将其打印出来的消费者。我们将忽略 .NET 客户端 API 中的一些细节,专注于更简单的开始。这是一个消息传递的“Hello World”。

在下图中,P是我们的生产者,C是我们的消费者。中间的盒子是队列 - RabbitMQ 代表消费者保存的消息缓冲区。

.NET 客户端库

RabbitMQ 支持多种协议,本教程使用AMQP 0-9-1,它是一种开放的、通用的消息传递协议。RabbitMQ 提供了一些针对不同 语言环境 的客户端,我们将使用 RabbitMQ 提供的 .NET 客户端。

客户端支持 .NET Core 以及 .NET Framework 4.5.1+。本教程将使用 .NET Core,因此您需要确保客户端已 安装 并且路径添加到PATH系统变量。

您也可以使用 .NET Framework 来完成本教程,但设置步骤会有所不同。

RabbitMQ .NET 客户端 5.0 及更高版本通过 nuget 发布。

本教程假定您在 Windows 上使用 PowerShell。在 MacOS 和 Linux 上,几乎所有 shell 也都可以正常工作。

安装#

首先让我们验证您在PATH系统变量是否有 .NET Core 工具链:

dotnet --help

应该产生帮助信息。

现在,让我们生成两个项目,一个用于发布者,另一个用于消费者:

dotnet new console --name Send
mv Send/Program.cs Send/Send.cs
dotnet new console --name Receive
mv Receive/Program.cs Receive/Receive.cs

这将创建两个名为SendReceive的新目录。

然后,我们添加客户端依赖项。

cd Send
dotnet add package RabbitMQ.Client
dotnet restore
cd ../Receive
dotnet add package RabbitMQ.Client
dotnet restore

我们已经建立了 .NET 项目,现在我们可以编写一些代码。

发送#

我们将调用我们的消息发布者(发送者)Send.cs和我们的消息消费者(接收者)Receive.cs。发布者将连接到 RabbitMQ,发送一条消息,然后退出。

Send.cs 中,我们需要使用一些命名空间:

using System;
using RabbitMQ.Client;
using System.Text;

设置类:

class Send
{
    public static void Main()
    {
        ...
    }
}

然后,我们可以创建一个连接,连接到服务器:

class Send
{
    public static void Main()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using (var connection = factory.CreateConnection())
        {
            using (var channel = connection.CreateModel())
            {
                ...
            }
        }
    }
}

该连接抽象了套接字连接,并为我们处理协议版本的协商和身份验证等。在这里,我们连接的是本地机器上的代理, 因此是localhost。如果我们想连接到其他机器上的代理,我们只需在此指定其名称或 IP 地址。

接下来,我们创建一个通道,该 API 的主要功能是把获得信息保存起来。

想要发送消息,我们必须为需要发送的消息声明一个队列,然后我们就可以把消息发布到队列中:

using System;
using RabbitMQ.Client;
using System.Text;

class Send
{
    public static void Main()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.QueueDeclare(queue: "hello",
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);

            string message = "Hello World!";
            var body = Encoding.UTF8.GetBytes(message);

            channel.BasicPublish(exchange: "",
                                 routingKey: "hello",
                                 basicProperties: null,
                                 body: body);
            Console.WriteLine(" [x] Sent {0}", message);
        }

        Console.WriteLine(" Press [enter] to exit.");
        Console.ReadLine();
    }
}

声明队列是 幂等 的 - 只有当它不存在时才会被创建。消息内容是一个字节数组,所以您可以用喜欢的任意方式编码。

当上面的代码完成运行时,通道和连接将被释放。这就是我们的发布者。

Send.cs 源码)

发送不起作用!

如果这是您第一次使用 RabbitMQ,并且您没有看到“已发送”消息,那么您可能会挠着头想知道错误出在什么地方。也许是代理程序启动时没有足够的可用磁盘空间(默认情况下,它至少需要50 MB空闲空间),因此拒绝接收消息。
必要时检查代理程序日志文件来确认和减少限制。配置文件 文档 将告诉您如何设置disk_free_limit

接收#

至于消费者,它是把消息从 RabbitMQ 拉取过来。因此,与发布消息的发布者不同,我们会保持消费者持续不断地运行,监听消息并将其打印出来。

代码(在 Receive.cs 中)具有与Send差不多一样的using声明:

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Text;

设置与发布者相同;我们开启一个连接和一个通道,并声明我们将要使用的队列。请注意,这需要与Send发布到的队列相匹配。

class Receive
{
    public static void Main()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using (var connection = factory.CreateConnection())
        {
            using (var channel = connection.CreateModel())
            {
                channel.QueueDeclare(queue: "hello",
                                     durable: false,
                                     exclusive: false,
                                     autoDelete: false,
                                     arguments: null);
                ...
            }
        }
    }
}

请注意,我们在这里也声明了队列。因为我们可能会在发布者之前启动消费者,所以我们希望在我们尝试从它中消费消息之前确保队列已存在。

我们即将告诉服务器将队列中的消息传递给我们。由于它会异步推送消息,因此我们提供了一个回调。这就是EventingBasicConsumer.Received事件处理程序所做的事情。

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Text;

class Receive
{
    public static void Main()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.QueueDeclare(queue: "hello",
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body;
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine(" [x] Received {0}", message);
            };
            channel.BasicConsume(queue: "hello",
                                 autoAck: true,
                                 consumer: consumer);

            Console.WriteLine(" Press [enter] to exit.");
            Console.ReadLine();
        }
    }
}

Receive.cs 源码)

组合在一起#

打开两个终端。

运行消费者:

cd Receive
dotnet run

运行生产者:

cd Send
dotnet run

消费者将打印它通过 RabbitMQ 从发布者处获得的消息。消费者将继续运行、等待新消息(按Ctrl-C将其停止),可以尝试从开启另一个终端运行发布者。

接下来可以跳转到 教程[2],构建一个简单的工作队列。

写在最后#

本文翻译自 RabbitMQ 官方教程 C# 版本。如本文介绍内容与官方有所出入,请以官方最新内容为准。水平有限,翻译的不好请见谅,如有翻译错误还请指正。

先决条件
本教程假定 RabbitMQ 已经安装,并运行在localhost 标准端口(5672)。如果你使用不同的主机、端口或证书,则需要调整连接设置。

从哪里获得帮助
如果您在阅读本教程时遇到困难,可以通过邮件列表 联系我们

主题#

(使用 .NET 客户端)

教程[4] 中,我们改进了我们日志系统。我们用direct交换器替换了只能呆滞广播消息的fanout交换器,从而可以有选择性的接收日志。

虽然使用direct交换器改进了我们的系统,但它仍然有局限性 - 不能基于多个标准进行路由。

在我们的日志系统中,我们可能不仅要根据日志的严重性订阅日志,可能还要根据日志分发源来订阅日志。或许您可能从 unix syslog 工具中了解过这种概念,syslog 工具在路由日志的时候是可以既基于严重性(info/warn/crit…)又基于设备(auth/cron/kern…)的。

这种机制会给我们带来极大的灵活性 - 我们可以仅监听来自cron的关键错误日志,与此同时,监听来自kern的所有日志。

要在我们的日志系统中实现这一特性,我们需要学习更复杂的topic交换器。

Topic交换器#

发送到topic交换器的消息不能随意指定routing key,它必须是一个由点分割的单词列表,这些单词可以是任意内容,但通常会在其中指定一些与消息相关的特性。请看一些合法的路由键示例:stock.usd.nysenyse.vmwquick.orange.rabbit,路由键可以包含任意数量的单词,但不能超过255个字节的上限。

binding key也必须是相同的形式,topic交换器的背后逻辑与direct交换器类似 - 使用指定路由键发送的消息会被分发到与其绑定键匹配的所有队列中。不过对于绑定键来说,有两个重要的特殊情况需要注意:

  • *(星号)可以代替一个单词。
  • #(哈希)可以代替零个或多个单词。

下图示例是对上述内容最简单的解释:

在这个示例中,我们打算发送的消息全是用来描述动物的,这些消息会使用由三个单词(两个点)组成的路由键来发送。在路由键中,第一个单词用来描述行动速度、第二个是颜色、第三个是物种,即:<speed>.<colour>.<species>

我们创建了三个绑定:Q1绑定了键.orange.,Q2绑定了键*.*.rabbitlazy.#

这些绑定可以被概括为:

  • Q1对所有橙色的动物感兴趣。
  • Q2对兔子以及所有行动缓慢的动物感兴趣。

路由键为quick.orange.rabbit的消息会被发送到这两个队列,消息lazy.orange.elephant也会被发送到这两个队列。另外,quick.orange.fox只会进入第一个队列,lazy.brown.fox只会进入第二个队列。lazy.pink.rabbit只会被发送到第二个队列一次,尽管它匹配了两个绑定(避免了消息重复)。quick.brown.fox没有匹配的绑定,因此它将会被丢弃。

如果我们打破约定,发送使用一个或四个单词(例如:orangequick.orange.male.rabbit)作路由键的消息会发生什么?答案是,这些消息因为没有匹配到任何绑定,将被丢弃。

但是,另外,例如路由键为lazy.orange.male.rabbit的消息,尽管它有四个单词,也会匹配最后一个绑定,并将被发送到第二个队列。

Topics 交换器
topic交换器的功能是很强大的,它可以表现出一些其他交换器的行为。
当一个队列与键(哈希)绑定时, 它会忽略路由键,接收所有消息,这就像fanout交换器一样。
当特殊字符*(星号)和(哈希)未在绑定中使用时,topic交换器的行为就像direct交换器一样。

组合在一起#

我们将要在我们的日志系统中使用topic交换器,首先假设日志的路由键有两个单词组成:<facility>.<severity>

代码与上一篇 教程 中的代码几乎相同。

EmitLogTopic.cs的代码:

using System;
using System.Linq;
using RabbitMQ.Client;
using System.Text;

class EmitLogTopic
{
    public static void Main(string[] args)
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.ExchangeDeclare(exchange: "topic_logs",
                                    type: "topic");

            var routingKey = (args.Length > 0) ? args[0] : "anonymous.info";
            
            var message = (args.Length > 1)
                          ? string.Join(" ", args.Skip(1).ToArray())
                          : "Hello World!";
            var body = Encoding.UTF8.GetBytes(message);
            
            channel.BasicPublish(exchange: "topic_logs",
                                 routingKey: routingKey,
                                 basicProperties: null,
                                 body: body);
                                 
            Console.WriteLine(" [x] Sent '{0}':'{1}'", routingKey, message);
        }
    }
}

ReceiveLogsTopic.cs的代码:

using System;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System.Text;

class ReceiveLogsTopic
{
    public static void Main(string[] args)
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.ExchangeDeclare(exchange: "topic_logs", type: "topic");
            var queueName = channel.QueueDeclare().QueueName;

            if(args.Length < 1)
            {
                Console.Error.WriteLine("Usage: {0} [binding_key...]",
                                        Environment.GetCommandLineArgs()[0]);
                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
                Environment.ExitCode = 1;
                return;
            }

            foreach(var bindingKey in args)
            {
                channel.QueueBind(queue: queueName,
                                  exchange: "topic_logs",
                                  routingKey: bindingKey);
            }

            Console.WriteLine(" [*] Waiting for messages. To exit press CTRL+C");

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body;
                var message = Encoding.UTF8.GetString(body);
                var routingKey = ea.RoutingKey;
                Console.WriteLine(" [x] Received '{0}':'{1}'",
                                  routingKey,
                                  message);
            };
            channel.BasicConsume(queue: queueName,
                                 autoAck: true,
                                 consumer: consumer);

            Console.WriteLine(" Press [enter] to exit.");
            Console.ReadLine();
        }
    }
}

请运行以下示例:

要接收所有日志:

cd ReceiveLogsTopic
dotnet run "#"

要接收来自设备kern的所有日志:

cd ReceiveLogsTopic
dotnet run "kern.*"

或者,如果您只想监听级别为critical的日志:

cd ReceiveLogsTopic
dotnet run "*.critical"

您可以创建多个绑定:

cd ReceiveLogsTopic
dotnet run "kern.*" "*.critical"

使用路由键kern.critical发出日志:

cd EmitLogTopic
dotnet run "kern.critical" "A critical kernel error"

希望运行这些程序能让您玩得开心。要注意的是,这些代码没有针对路由键和绑定键做任何预设,您可以尝试使用两个以上的路由键参数。

EmitLogTopic.csReceiveLogsTopic.cs 的完整源码)

接下来,在 教程[6] 中将了解如何将往返消息作为远程过程调用。

写在最后#

本文翻译自 RabbitMQ 官方教程 C# 版本。如本文介绍内容与官方有所出入,请以官方最新内容为准。水平有限,翻译的不好请见谅,如有翻译错误还请指正。

  • 原文链接:RabbitMQ tutorial - Topics
  • 实验环境:RabbitMQ 3.7.4 、.NET Core 2.1.3、Visual Studio Code
  • 最后更新:2018-09-06

环境检查

1
ls /sys/firmware/efi/efivars #UEFI/BIOS检测

若该目录不存在,则 ArchISO 是以 BIOS/CSM 模式启动,否则是以 UEFI 模式启动。

通常而言,UEFI 系统须使用 GPT 分区才能引导,BIOS 系统须使用 MBR 分区才能引导。

分区

fdisk

1
fdisk -l //查看所有分区情况

常用fdisk命令:p 显示当前磁盘分区,d 删除指定分区,n 创建新分区, a 为指定分区创建启动标记,t 更改分区格式, w将磁盘分区信息写入磁盘。

parted

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# parted /dev/sda

检查 MINOR #对文件系统进行一个简单的检查
cp [FROM-DEVICE] FROM-MINOR TO-MINOR #将文件系统复制到另一个分区
help [COMMAND] #打印通用求助信息,或关于 COMMAND 的信息
mklabel 标签类型 #创建新的磁盘标签 (分区表)
mkfs MINOR 文件系统类型 #在 MINOR 创建类型为“文件系统类型”的文件系统
mkpart 分区类型 [文件系统类型] 起始点 终止点 #创建一个分区
mkpartfs 分区类型 文件系统类型 起始点 终止点 #创建一个带有文件系统的分区
move MINOR 起始点 终止点 #移动编号为 MINOR 的分区
name MINOR 名称 #将编号为 MINOR 的分区命名为“名称”
print [MINOR] #打印分区表,或者分区
quit #退出程序
rescue 起始点 终止点 #挽救临近“起始点”、“终止点”的遗失的分区
resize MINOR 起始点 终止点 #改变位于编号为 MINOR 的分区中文件系统的大小
rm MINOR #删除编号为 MINOR 的分区
select 设备 #选择要编辑的设备
set MINOR 标志 状态 #改变编号为 MINOR 的分区的标志


格式化分区

1
2
3
4
mkfs.vfat -F 32 /dev/sda1 #生成ESP分区的文件系统FAT32
mkswap /dev/sda2 #格式化swap
mkfs.ext4 /dev/sda3 #格式化ext4
mkfs.xfx /dev/sda4 #格式化xfs

分区方案

1
2
3
4
/dev/sda1 /boot 500M
/dev/sda2 swap 8G(根据内存大小调整)
/dev/sda3 / 200G
/dev/sda4 /home 剩余所有空间

挂载分区

1
#mount /dev/sda6 /mnt # 挂载根分区

非UEFI挂载boot

1
2
# mkdir -p /mnt/boot
# mount /dev/sda1 /mnt/boot

建立efi目录,把EFI分区装载到刚建立的efi目录上。

1
2
#mkdir -p /mnt/boot/efi
#mount /dev/sdc1 /mnt/boot/efi

挂载交换分区和home

1
2
3
#swap on /dev/sda5
#mkdir -p /mnt/home
#mount /dev/sda7 /mnt/home

生成引导

  • BIOS:

依赖包: grub os-prober

1
2
# grub-install --recheck /dev/<目标磁盘>
# grub-mkconfig -o /boot/grub/grub.cfg
  • UEFI:—如果BIOS是UEFI的,就要用下面的命令安装grub了

依赖包: dosfstools grub efibootmgr

1
2
# grub-install --target=x86_64-efi --efi-directory=<EFI 分区挂载点> --bootloader-id=arch_grub --recheck
# grub-mkconfig -o /boot/grub/grub.cfg

低格填零

1
# dd if=/dev/zero of=/dev/sda bs=16M

1. 下载镜像 制作启动U盘

Arch Linux 官方网站 https://www.archlinux.org/

制作启动盘工具 Rufus - 轻松创建 USB 启动盘

Linux下

1
dd if=*iso of /dev/sdb bs=41M

2. 网络连接

参考 Linux配置网络及SSH配置

3. 选择软件源

推荐国内的用户选择http://mirrors.ustc.edu.cn 默认的mirrorlist是开启所有源的,因此我们使用sed先在所有源的前面加上#

1
2
#sed -i "s/^\b/#/g" /etc/pacman.d/mirrorlist
#nano /etc/pacman.d /mirrorlist

将mirrors.ustc.edu.cn前面的#去掉

4. 分区/格式化/挂载

参考 Linux分区

5. 安装基本系统

1. 将基本系统安装到根目录上去

1
#pacstrap /mnt base base-devel
其实,这里安装的基本系统也肯定有自己用不到的冗余功能,例如我就用不到nano文本编辑器,但系统会默认给安上。如果知道基本系统每个文件的作用,其实也完全可以自定义安装。比如:
1
2
#pacstrap /mnt bash coreutils file filesystem grub2 linux pacman \
procps-ng syslog-ng glibc systemd-sysvcompat shawd dhcpcd vi
> 如果你想使用ifconfig之类的工具,请在上面加上net-tools

2. 生成fstab

用下面命令生成 fstab。如果想使用 UUIDs,使用 -U 选项;如果想使用标签,用 -L 选项.

1
#genfstab -U -p /mnt >>/mnt/etc/fstab
> [red]**后面如果出现问题,请不要再次运行genfstab**[red],如果需要,手动编辑/etc/fstab /etc/fstab文件在运行genfstab后应该被检查一下。如果之前你生成了一个EFI系统分区,那么 genfstab给EFI分区添加了错误的选项,会导致无法启动。因此你需要移除EFI分区的所有选项,除了noatime. 对其他分区, 替换"codepage=cp437" 为 "codepage=437" , 会挂载失败导致systemd进入恢复模式。

3. 切换到新系统中

1
2
#arch-chroot /mnt
#sh-4.2#bash
> 到这一步之后,开始系统的主要配置,如果下面文件不存在,需要手动创建。 > 理解并完全安装步骤设置是保证系统配置成功的关键。

4. 对新的基本系统进行设置

写入本机的字符编码方式

1
2
3
#nano /etc/locale.conf #

LANG=en_US.UTF-8 #简略写法 echo LANG= en_US.UTF-8 >> locale.conf

locale.conf 文件默认不存在,一般设置LANG就行了,它是其它设置的默认值。

1
2
3
4
/etc/locale.conf

LANG=zh_CN.UTF-8
LC_TIME=en_GB.UTF-8

修改本机编码

1
# nano /etc/locale.gen  将用不到的编码全删掉,只保留en_US与zh_CN的几行。 

默认情况下 /etc/locale.gen 是一个仅包含注释文档的空文件。选定你需要的本地化类型(移除前面的#即可), 比如中文系统可以使用:

1
2
3
4
5
en_US.UTF-8 UTF-8
zh_CN.GB18030 GB18030
zh_CN.GBK GBK
zh_CN.UTF-8 UTF-8
zh_CN GB2312

对系统的编码进行更新

1
#locale-gen 

写入本机的名称

1
# nano /etc/hostname #简略写法:echo {name} >/etc/hostname,也是一样的。

写入键盘布局方案

1
#nano /etc/vconsole.conf

美式键盘,如下:

1
2
3
KEYMAP=us
FONT=
FONT_MAP=

写入时区

1
2
3
# nano /etc/timezone

Asia/Shanghai

建立时区的软链接

1
#ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

设定系统将用的时间方案

1
#hwclock --systohc --utc

这个时间方案我是试过很多次,如果是双系统,电脑里还有win系统的话,建议设为:–localtime,否则可设为—utc。不过,我现在虽然也用双系统,但还是设的utc,因为设为–localtime虽然在win下时间不会出错,但回到linux下,经常系统会有些古怪的问题,比如,升级系统之时,报密钥错误。使用–utc,虽然在linux下时间会慢8个多小时,但毕竟对整个系统没有影响。

生成内核的启动镜象。

1
#mkinitcpio -p linux

安装必要工具

安装必要的网络工具以便于开机后可以配置网络连接(包括无线)

1
2
3
4
#pacman –S wpa_supplicant net-tools
#pacman -S dialog
#pacman -S netctl
#pacman -S wireless_tools

6. 安装引导

安装grub

1
2
#pacman -S grub-bios os-prober
#grub-install /dev/sda

UEFI 注意分区,参考: Linux分区.格式化.挂载

1
2
#pacman -S grub-bios efibootmgr os-prober
#grub-install --efi-directory=/boot/efi --bootloader-id=arch-grub --target=x86_64-efi

生成启动菜单

1
2
3

#grub-mkconfig -o /boot/grub/grub.cfg
#nano /boot/grub/grub.cfg

生成grub引导windows

如何生成grub引导文件grub.cfg 这里我们需要充分参考点击打开链接grub的说明。首先,需要额外安装一个 os-prober的软件包,直接pacman就行;然后grub-makeconfig 到/boot/grub/grub.cfg 。此时才能生成可以引导多系统的引导文件.如下图。
Window引导

开机自启网络

1
2
#systemctl enable dhcpcd@.service
#dhcpcd

卸载挂载的分区并重启

1
2
#umount /mnt/{boot,home,mnt}
# reboot

基本系统已安装完成

7. 系统配置

忘记安装net-tools补救

1
2
ip link show #查看网卡
ip link set eth0 up # 启用网卡

如果是DHCP的当然简单,直接dhcpcd即可,如果是固定IP的,则要如下操作:

1
2
3
#ip addr add 固定IP/24 dev eth0
#ip link set dev eth0 up
#ip route add default via 网关

系统更新

1
#pacman –Syu

添加用户

1
2
3
#useradd -m 新用户 #新建用户
#passwd 新用户 #指定密码:
#usermod -a -G video,audio,lp,log,wheel,optical,scanner,games,users,storage,power 新用户 #指定用户所在的组

sudo权限

1
nano /etc/sudoers (添加sudo权限)

放开%wheel %sudo权限

sudo命令补全

1
2
#sudo pacman -S bash-completion 
#echo "source /usr/share/bash-completion/bash_completion" >>/home/$USER/.bashrc

更新源列表

1
#pacman -S reflector 

reflector是一个可以从arch官方MirrorStatus列表取回最新mirrorlist的脚本,并且可以根据最新同步时间和速度排序。
下面先说如何自动配置源列表。直接终端输入命令5(注意备份原有源列表)

1
#reflector --verbose --country 'China' -l 200 -p http --sort rate --save /etc/pacman.d/mirrorlist

安装yaourt

1
#vim /etc/pacman.conf
1
2
3
4
[archlinuxcn]
#The Chinese Arch Linux communities packages.
SigLevel = Optional TrustAll
Server = http://repo.archlinuxcn.org/$arch
1
# pacman -Syu yaourt

安装powerpill

1
#yaourt -S powerpill

powerpill是一个可以从多个源多线程下载软件包的程序,类似于迅雷一样,可以明显提升更新速度,相当于pacman的外壳程序,使用方法完全和pacman相同。下面说说powerpill,玩arch的人不知道powerpill是不行的,需要注意的是它也是要调用reflector的,但并不是作为依赖。如果安装reflector后powerpill更新前会默认从mirrorstatus取回45个最新更新的源地址,然后并行下载,否则就是读取/etc/pacman.d/mirrorlist然后配置下载。当然我们推荐第一种,总不能每次都手动执行

7. 驱动显卡

安装显卡驱动

1
2
3
4
5
6
7
# pacman -S mesa
# lspci | grep VGA(查看本机的显卡类型)
# pacman -Ss xf86-video | less(查看能够安装的显卡类型)
# pacman -S …… 安装显卡驱动(或者可以直接所有驱动都自动安装)
# pacman –S xf86-video-vesa
# pacman –S xf86-video-nouveau #如果是ATI显卡的话,要安xf86-video-ati;
# pacman –S virtualbox-guest-utils #虚拟机

安装系统基础程序:

1
2
# pacman -S xorg-server xorg-xinit xorg-utils xorg-server-utils dbus # 先安装x-window服务
# pacman –S xterm xorg-xclock xorg-twm # 安装测试环境

重设系统的编码方式

编辑.xinitrc,把以下内容添加到文件最开始。内可以使用你所喜欢的编辑器,比如nano

1
2
LANG=zh_CN.UTF-8
LC_ALL="zh_CN.UTF-8"

更新系统的编码:

1
#locale-gen

更新一下系统的时间

1
2
# date -s "2013-01-14 14:40:10"
# hwclock --systohc

音频管理

1
# pacman -S alsa-utils pulseaudio-alsa

安装网络管理工具

1
2
3
# pacman –S networkmanager network-manager-applet wireless_tools
# systemctl enable NetworkManager
# systemctl start NetworkManager

安装桌面

击右键菜单,找到文件管理器,然后进入到目录/usr/share/applications/下,你会看到你已经安装完成的程序,全都可以从这儿启动。此时,你不妨复制几个常用的到你的用户目录:/home/新用户/桌面/下去。复制之后,你会在你的桌面上,看到这些程序的启动器。

安装完ibus之后,在/home/$USER/.xinitrc文件中,写入:

1
2
3
4
export GTK_IM_MODULE=ibus
export QT_IM_MODULE=ibus
export XMODIFIERS=@im=ibus
ibus-daemon -d -x

Windows下的磁盘挂载
参考Windows下的磁盘挂载

Xfce主题

字体及补丁

1
2
3
# pacman -S ttf-dejavu ttf-ubuntu-font-family ttf-arphic-ukai ttf-arphic-uming
# pacman -S wqy-microhei wqy-bitmapfont wqy-zenhei ttf-fireflysung
$ yaourt -S cairo-ubuntu libxft-ubuntu freetype2-ubuntu fontconfig-ubuntu #以普通用户身份执行

安装系统主题:

1
sudo pacman -S gtk-aurora-engine gtk-engine-murrine 

鼠标主题:

1
sudo pacman -S xcursor-vanilla-dmz xcursor-vanilla-dmz-aa

图标主题:

1
# pacman -S gnome-icon-theme-extras oxygen-icons human-icon-theme lxde-icon-theme tangerine-icon-theme

针对笔记本电脑的配置:(Speed-step 、 Suspend 等功能)

1
2
# pacman -S  gnome-power-manager  volumeicon
$ yaourt -S laptop-mode-tools pmount

Grub主题
在启动过程中发现Xfce桌面启动载入真心简陋,没有关系,我们在AUR里下载一个balou并设置就好了。

1
$ yaourt -S archlinux-themes-balou

下面来配置grub的启动界面。AUR里有一个非常棒的包grub2-theme-archlinux

1
$ yaourt -S grub2-theme-archlinux

安装后编辑/etc/default/grub,
#GRUB_THEME="/path/to/gfxtheme"改为GRUB_THEME="/boot/grub/themes/Archlinux/theme.txt"
GRUB_GFXMODE=auto改为GRUB_GFXMODE=1024x768修改完成后重新生成一下启动文件

1
# grub-mkconfig -o /boot/grub/grub.cfg

安装 i3 窗口管理器

1
# pacman -S i3

安装 lightdm 显示管理器,

1
# pacman -S lightdm-gtk3-greeter

然后

1
2
# systemctl enable lightdm
# systemctl start lightdm

8. 桌面及美化

本文方案适用于Microsoft Sql Server 2008/2012/2012 r2/2014版本,以下简称MSSQLSERVER。

MSSQL默认是不允许远程连接,并且禁用sa账户的。如果想要在本地用SSMS连接远程服务器上的MSSQLSERVER,需要做两个部分的配置:

1. SQL SERVER MANAGEMENT STUDIO(SSMS)

2. SQL SERVER配置管理器(SQL SERVER CONFIGURATION MANAGER - SSCM)

并且需要注意的是,有些地方如果没有生效,请重启一下sql server(可以从SSCM里,也可以从系统服务中找),下面是详细的步骤:

STEP1. 打开SSMS,使用Windows身份连接数据库,登录后,右键选择“属性”

STEP 2. 选择“安全性”,选中SQL SERVER和Windows身份验证模式

STEP 3. 再选择“连接”,勾选“允许远程连接此服务器”,然后点击“确定”按钮。

STEP 4. 展开“安全性” -》登录名 -》sa,右键选择“属性”

STEP 5. 在“常规”中,改好你自己的密码,这是你sa登录的密码。

STEP 6. 在“状态”中,启用sa登录,点击“确定”按钮

STEP 7. 右键数据库server,选择“方面”

STEP 8. 选择“服务器配置”,找到RemoteAccessEnabled,设置为“True”

STEP 9. 重新启动SQL SERVER服务,退出当前的连接,这时候应该可以用sa进行登录了。

STEP 10. 配置SSCM,选中左侧的“SQL SERVER服务”,确保右侧的“SQL SERVER”以及“SQL SERVER BROWER”正在运行,选择“网络配置”,双击TCP/IP,确保状态为“启用”

STEP 11. 在Client里也确保TCP/IP是启用的,默认的端口都是1433,可以自己修改,非默认端口需要在连接字符串里显式指明。

STEP 12. 到这里再次重启SQL SERVER服务,应该就可以用了。不过还不能用,确认防火墙端口设置,并把SQL SERVER安装目录下,C:\Program Files\Microsoft SQL Server\MSSQL10.SQLEXPRESS\MSSQL\Binn\sqlservr.exe添加到允许的列表中。

1、安装nuget包MSBuildTasks

2、编辑项目的csproj文件,找到被注释掉的target的beforebuild,去掉注释,添加如下代码。代码如下。

1
2
3
4
5
6
7
8
9
<Target Name="BeforeBuild">
<Version VersionFile="Propertiesversion.txt" Major="1" Minor="0" BuildType="Automatic" StartDate="09/01/2017" RevisionType="BuildIncrement">
<Output TaskParameter="Major" PropertyName="Major" />
<Output TaskParameter="Minor" PropertyName="Minor" />
<Output TaskParameter="Build" PropertyName="Build" />
<Output TaskParameter="Revision" PropertyName="Revision" />
</Version>
<AssemblyInfo CodeLanguage="CS" OutputFile="Properties\FileVersionInfo.cs" AssemblyFileVersion="$(Major).$(Minor).$(Build).$(Revision)" />
</Target>     

3、编译项目一次就会在项目文件夹下生成 Propertiesversion.txt

4、在AssemblyInfo.cs文件中包含了AssemblyVersion和AssemblyFileVersion,这里把AssemblyFileVersion单独放到了FileVersionInfo.cs中,编译时会自动生成FileVersionInfo.cs文件,其内容为AssemblyFileVersion,把该文件包含到项目中即可。这里并没有让程序自动生成AssemblyVersion。

这种方式生成版本号会在vs编译时更新版本号。

一、先来看一篇转载文章《在 VS2015 中使用 Qt4

http://tangzx.qiniudn.com/post-0111-qt4-vs2015.html 最早的原文,看不到了

https://github.com/district10/qt4-vs2015x64 原作者的github,里面的东东都下载不了了

二、firecat本人的教程

0、Qt官方

Qt4.8.7官方源码下载

https://download.qt.io/new_archive/qt/4.8/4.8.7/

官网的exe只提供了MSVC2010,没有更高版本的。高版本需要自己下载源码编译。

源码里面的配置文件已经提供了MSVC 2015的编译选项,\qt-everywhere-opensource-src-4.8.7\mkspecs\win32-msvc2015

参照官方提供的编译文档一步一步执行即可;但是配置文件里没有提供MSVC 2017的编译选项。

官方编译的文档

https://doc.qt.io/archives/qt-4.8/installation.html

https://doc.qt.io/archives/qt-4.8/configure-options.html

https://doc.qt.io/archives/qt-4.8/install-win.html

https://doc.qt.io/archives/qt-4.8/install-mac.html

https://doc.qt.io/qt-5/build-sources.html

1、Qt 4.8.7+MSVC 2017

推荐使用第三方提供的源码,它已经是修改好的,里面含有MSVC 2017编译选项,可以编译。

https://github.com/scharsig/Qt Qt4.8.7+MSVC2017源码

https://forum.qt.io/topic/91623/building-qt-4-8-7-with-visual-studio-2017 Qt4.8.7+MSVC2017论坛

https://github.com/sandym/qt-patches 仅供参考,编译补丁

https://github.com/Homebrew/formula-patches/tree/master/qt 仅供参考,编译补丁

https://github.com/BartVandewoestyne/qt_4_8_7_with_vs2017_patch 仅供参考,编译补丁

完整的编译过程:

下载第三方源码https://github.com/scharsig/Qt/tree/master/qt-4.8.7-vs2017 然后解压

-–step1—

Windows桌面-开始-程序-Visual Studio 2017-Visual Studio Tools-VC-x86 Native Tools Command Prompt for VS 2017

-–step2—

C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise>cd F:\Qt\setup-exe\4.8.7\Qt-master\qt-4.8.7-vs2017

-–step3—

F:\Qt\setup-exe\4.8.7\Qt-master\qt-4.8.7-vs2017>configure -help

-–step4—

F:\Qt\setup-exe\4.8.7\Qt-master\qt-4.8.7-vs2017>
configure -make nmake -debug-and-release -opensource -confirm-license -platform win32-msvc2017 -prefix F:\Qt\Qt4.8.7-msvc2017 -nomake examples -nomake tests

如果不想编译这么多功能模块,可以精简为:

configure -make nmake -debug-and-release -opensource -confirm-license -platform win32-msvc2017 -prefix F:\Qt\Qt4.8.7-msvc2017 \
  -no-qt3support -no-multimedia \
  -no-audio-backend -no-phonon -no-phonon-backend -no-libtiff \
  -no-libmng -no-dbus -no-nis -nomake examples -nomake tests

 -release              Compile and link Qt with debugging turned off. -debug                Compile and link Qt with debugging turned on. -nomake tests         Disable building of tests to speed up compilation -nomake examples      Disable building of examples to speed up compilation -confirm-license      Automatically acknowledge the LGPL 2.1 license.

-–step5—

F:\Qt\setup-exe\4.8.7\Qt-master\qt-4.8.7-vs2017>nmake

-–step6—

F:\Qt\setup-exe\4.8.7\Qt-master\qt-4.8.7-vs2017>nmake install

-–step7—

添加到Qt Creator

-–step8—

新建项目测试,Qt Creator+Qt4.8.7+MSVC2017编译项目时,如果报错:

intermediate\moc\moc_rs_actionzoompan.cpp:-1: error: C1041: 无法打开程序数据库“F:\CADCAM\QCAD\src\build-LibreCAD-v1.0.4-qt4-Desktop_Qt_4_8_7_MSVC2017_32bit-Debug\librecad\vc140.pdb”;如果要将多个 CL.EXE 写入同一个 .PDB 文件,请使用 /FS

解决办法:

在Qt Creator的项目文件,即.pro文件中,可以通过QMAKE_CXXFLAGS来给MSVC编译器传递编译开关。

QMAKE_CXXFLAGS += /FS

win32-msvc*:QMAKE_CXXFLAGS += /wd"4819" QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO -= -Zc:strictStrings 

MSVC 2017编译器常见错误的解决:

https://docs.microsoft.com/en-us/cpp/error-messages/compiler-errors-1/c-cpp-build-errors?view=vs-2017

2、Mac OS+Qt 4.8.7

笔者的Mac OS版本是MacOS-10.15-Catalina,高版本的OS和Clang已经不再支持Qt官方发布的Qt4了。

解决办法可以参见我的另一篇博文:https://blog.csdn.net/libaineu2004/article/details/104740623

https://trac.macports.org/ticket/58651 mac下编译qt4遇到问题

https://github.com/macports/macports-ports/tree/master/aqua/qt4-mac mac编译补丁