配置消息代理服务器-AmqpAdmin

最新推荐文章于 2023-03-11 18:32:18 发布

超速前行

最新推荐文章于 2023-03-11 18:32:18 发布

阅读量4.2k

点赞数

分类专栏： Spring AMQP 文章标签： AMQP RabbitMQ Java spring AmqpAdmin

本文链接：https://blog.csdn.net/sn_gis/article/details/41213879

版权

Spring AMQP 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

配置消息代理服务器-AmqpAdmin

AMQP规范描述了在消息代理中如何利用协议来配置队列，交换和绑定。这些操作可以使用org.springframework.amqp.core package中的AmqpAdmin接口来完成，这些操作从0.8版本规范到现在为止是通用的。

AmqpAdmin接口是基于Spring AMQP高度抽象的：

   
   public interfaceAmqpAdmin {
// Exchange Operations
void declareExchange(Exchange exchange);
void deleteExchange(String exchangeName);
// Queue Operations
Queue declareQueue();
String declareQueue(Queue queue);
void deleteQueue(String queueName);
void deleteQueue(String queueName, booleanunused, booleanempty);
void purgeQueue(String queueName, booleannoWait);
// Binding Operations
void declareBinding(Binding binding);
void removeBinding(Binding binding);
Properties getQueueProperties(String queueName);
}

无参方法declareQueue()在代理商定义队列，这个队列的名称是自动生成的。自动生成的队列的附件属性还有exclusive=true，autoDelete=true，durable=false。

declareQueue(Queue queue)接收Queue对象作为参数，并且返回queue的名称。如果你想让代理生成名称，这很有帮助。这和AnonymousQueue行车对比，它将生成UUID名称，并且设置exclusive和autoDelete属性为true。如果提供的队列的名称是空的，那么代理在声明队列的时候会生成名称，并且将名称返回给调用者。Queue自身并没有变化。这个方法只能通过RabbitAdmin编码直接调用。它不支持在应用程序上下文中自动生成。使用<rabbit:queue/>name属性设置为空或者不设置会创建AnonymousQueue。这是因为如果连接失败，重新声明的名称将会不一样。所以声明的名称应该固定，因为它们会在上下文的任何地方使用，例如，监听器：

   
   <rabbit:listener-container>
<rabbit:listener ref="listener" queue-names="#{someQueue.name}"/>
</rabbit:listener-container>

RabbitMQ对AmqpAdmin的实现是RabbitAdmin，使用XML配置如下：

   
   <rabbit:connection-factory id="connectionFactory"/>
<rabbit:admin id="amqpAdmin" connection-factory="connectionFactory"/>

当CachingConnectionFactory的缓存模式是CHANNEL，RabbitAdmin的实现将自动迟声明在一个应用上下文的Queues，Exchanges，Bindings。这些组件将在打开与消息代理的连接时声明。有一些方便的命名空间，使得这些变得很方便：

  
  <rabbit:queue id="tradeQueue"/>
<rabbit:queue id="marketDataQueue"/>
<fanout-exchange name="broadcast.responses"
xmlns="http://www.springframework.org/schema/rabbit">
<bindings>
<binding queue="tradeQueue"/>
</bindings>
</fanout-exchange>
<topic-exchange name="app.stock.marketdata"
xmlns="http://www.springframework.org/schema/rabbit">
<bindings>
<binding queue="marketDataQueue" pattern="${stocks.quote.pattern}"/>
</bindings>
</topic-exchange>

在上面的这个例子中，我们使用了匿名队列(实质上是框架帮我们生成队列的名称，而不是代理)，通过引用来引用它们。当然我们可以在声明队列的时候指定队列的名称，当然这个名称同样作为引用这些bean的标识。例如：

   
   <rabbit:queue name="stocks.trade.queue"/>

提示：

你可以同时提供id和name属性，这样你可以通过id引用这个队列。它同样允许一些标准的Spring特色，例如属性占位符或者SpEL作为Queue的name；这些属性在使用name作为标识符时候不可用。

队列还可以配置一些额外的参数，例如x-message-ttl,x-ha-policy。使用命名空间的支持它们可以通过使用<rabbit:queue-arguments>元素以键值对的方式提供：

  
  <rabbit:queue name="withArguments">
<rabbit:queue-arguments>
<entry key="x-ha-policy" value="all"/>
</rabbit:queue-arguments>
</rabbit:queue>

在默认的情况下，参数类型默认为字符串。对于其他的类型，我们需要提供类型信息。

   
   <rabbit:queue name="withArguments">
<rabbit:queue-arguments value-type="java.lang.Long">
<entry key="x-message-ttl" value="100"/>
</rabbit:queue-arguments>
</rabbit:queue>

对于混合类型，我们需要为每一个entry提供：

   
   <rabbit:queue name="withArguments">
<rabbit:queue-arguments>
<entry key="x-message-ttl">
<value type="java.lang.Long">100</value>
</entry>
<entry key="x-ha-policy" value="all"/>
</rabbit:queue-arguments>
</rabbit:queue>

在Spring Framework3.2之后，它可以声明的更为简洁：

   
   <rabbit:queue name="withArguments">
<rabbit:queue-arguments>
<entry key="x-message-ttl" value="100" value-type="java.lang.Long"/>
<entry key="x-ha-policy" value="all"/>
</rabbit:queue-arguments>
</rabbit:queue>

重点：

RabbitMQ代理不允许声明参数不一致的队列。例如，如果一个队列已经存在，没有time to live 参数，紧接着你又试图去使用下列参数去声明一个队列 key="x-message-ttl" value="100"，将会有异常抛出。

默认的情况下，RabbitAdmin会立马停止处理所有的声明，如果有异常出现。这样将引起连锁反应，例如监听容器因为队列没有声明而导致初始化失败。

这个问题可以通过设置RabbitAdmin的ignore-declaration-failures为true来完成。这一设置将会导致RabbitAdmin记录异常，并且继续声明其他的元素。

自从1.3版本开始，可以配置HeaderExchange...（没明白它的作用）

   
   <rabbit:headers-exchange name="headers-test">
<rabbit:bindings>
<rabbit:binding queue="bucket">
<rabbit:binding-arguments>
<entry key="foo" value="bar"/>
<entry key="baz" value="qux"/>
<entry key="x-match" value="all"/>
</rabbit:binding-arguments>
</rabbit:binding>
</rabbit:bindings>
</rabbit:headers-exchange>

如何通过Java来配置AMQP框架，看看下面的例子，使用@Configuration类AbstractStockRabbitConfiguration，它有RabbitClientConfiguration和RabbitServerConfiguration两个子类。 AbstractStockRabbitConfiguration的代码如下：

   
   @Configuration
public abstract class AbstractStockAppRabbitConfiguration {
@Bean
public ConnectionFactory connectionFactory() {
CachingConnectionFactory connectionFactory =
newCachingConnectionFactory("localhost");
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
returnconnectionFactory;
}
@Bean
public RabbitTemplate rabbitTemplate() {
RabbitTemplate template = newRabbitTemplate(connectionFactory());
template.setMessageConverter(jsonMessageConverter());
configureRabbitTemplate(template);
returntemplate;
}
@Bean
public MessageConverter jsonMessageConverter() {
return newJsonMessageConverter();
}
@Bean
public TopicExchange marketDataExchange() {
return newTopicExchange("app.stock.marketdata");
}
// additional code omitted for brevity
}

在这个例子中，Server的配置如下：

   
   @Configuration 
public class RabbitServerConfiguration extends AbstractStockAppRabbitConfiguration {
@Bean
public Queue stockRequestQueue() {
return new Queue("app.stock.request");
}
}

这是@Configuration类继承链的最末端。最末端结果是当应用启动的时候TopicExchange和Queue将被声明。在Server的配置中没有绑定TopicExchange和Queue，这些将在客户端应用中做。这里队列被绑定到默认的Exchange，这种定义是规范中定义的。

客户端的配置稍微复杂一些：

   
   @Configuration
public class RabbitClientConfiguration extends AbstractStockAppRabbitConfiguration {
@Value("${stocks.quote.pattern}")
private String marketDataRoutingKey;
@Bean
public Queue marketDataQueue() {
return amqpAdmin().declareQueue();
}
/**
* Binds to the market data exchange. Interested in any stock quotes
* that match its routing key.
*/
@Bean
public Binding marketDataBinding() {
return BindingBuilder.bind(
marketDataQueue()).to(marketDataExchange()).with(marketDataRoutingKey);
}
// additional code omitted for brevity
}

条件声明

默认情况下，queues，exchanges和bindings通过RabbitAdmin实例进行声明，RabbitAdmin实例随着应用上下文的启动创建。

注意：

自从1.2版本发以来，条件声明这些元素成为可能。当一个应用连接到多个代理的时候，这会特别有用，你需要指明你要声明元素的代理。

实现Declarable接口的类，代表着这些元素，它提供了两个方法：shouldDeclare()和getDeclaringAdmins()。RabbitAdmin使用这些方法来决定一个实例是否应该在当前连接上处理声明。

这些属性可以在命名空间中进行配置。

   
   <rabbit:admin id="admin1" connection-factory="CF1"/>
<rabbit:admin id="admin2" connection-factory="CF2"/>
<rabbit:queue id="declaredByBothAdminsImplicitly"/>
<rabbit:queue id="declaredByBothAdmins" declared-by="admin1, admin2"/>
<rabbit:queue id="declaredByAdmin1Only" declared-by="admin1"/>
<rabbit:queue id="notDeclaredByAny" auto-declare="false"/>
<rabbit:direct-exchange name="direct" declared-by="admin1, admin2">
<rabbit:bindings>
<rabbit:binding key="foo" queue="bar"/>
</rabbit:bindings>
</rabbit:direct-exchange>

注意，auto-declare属性默认情况下为true，如果declare-by属性没有提供，那么所有的RabbitAdmin都将声明这个实体。

同样，可以基于@Configuration进行配置。

   
   @Bean
public RabbitAdmin admin() {
RabbitAdmin rabbitAdmin = newRabbitAdmin(cf1());
rabbitAdmin.afterPropertiesSet();
returnrabbitAdmin;
}
@Bean
public RabbitAdmin admin2() {
RabbitAdmin rabbitAdmin = newRabbitAdmin(cf2());
rabbitAdmin.afterPropertiesSet();
returnrabbitAdmin;
}
@Bean
public Queue queue() {
Queue queue = newQueue("foo");
queue.setAdminsThatShouldDeclare(admin());
returnqueue;
}
@Bean
public Exchange exchange() {
DirectExchange exchange = newDirectExchange("bar");
exchange.setAdminsThatShouldDeclare(admin());
returnexchange;
}
@Bean
public Binding binding() {
Binding binding = newBinding("foo", DestinationType.QUEUE, exchange().getName(), "foo",
null);
binding.setAdminsThatShouldDeclare(admin());
returnbinding;
}