Java RabbitTemplate类代码示例

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
public String checkRabbitMQAMQPProtocol(String messageAsString,
                                        String url,
                                        String user,
                                        String password,
                                        String vhost) throws Exception {
    org.springframework.amqp.rabbit.connection.CachingConnectionFactory cf =
            new org.springframework.amqp.rabbit.connection.CachingConnectionFactory();
    URL formattedUrl = new URL("http://" + url);
    cf.setHost(formattedUrl.getHost());
    cf.setPort(formattedUrl.getPort());
    cf.setUsername(user);
    cf.setPassword(password);
    cf.setVirtualHost(vhost);
    RabbitAdmin admin = new RabbitAdmin(cf);
    org.springframework.amqp.core.Queue queue = new org.springframework.amqp.core.Queue("myQueue");
    admin.declareQueue(queue);
    TopicExchange exchange = new TopicExchange("myExchange");
    admin.declareExchange(exchange);
    admin.declareBinding(
            BindingBuilder.bind(queue).to(exchange).with("foo.*"));
    RabbitTemplate template = new RabbitTemplate(cf);
    template.convertAndSend("myExchange", "foo.bar", messageAsString);
    String receivedMessage = template.receiveAndConvert("myQueue").toString();
    return receivedMessage;
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
/**
 * @Title: call
 * @Description: call类型，点对点发送接收消息
 * @param topicRoutingKey
 * @param serverName
 * @param bodyMsg
 * @param outTimeMillis
 * @throws Exception 设定文件
 * @return Map<String,Object>    返回类型
 */
public Map<String,Object> call(String topicRoutingKey,String serverName,Map<String,Object> bodyMsg,int outTimeMillis) throws Exception{
    Map<String,Object> sendMsg = new HashMap<String,Object>();
    sendMsg.put("mqkey",topicRoutingKey+"."+serverName);
    sendMsg.put("mqtype","call");
    sendMsg.put("mqbody",bodyMsg==null?new HashMap<String,Object>():bodyMsg);

    String topicMessage = JSON.toJSONString(sendMsg, JsonFilter.filter);
    Message message=new Message(topicMessage.getBytes("UTF-8"),new MessageProperties());

    RabbitTemplate directTemplate =new RabbitTemplate();
    directTemplate.setConnectionFactory(connectionFactory);
    directTemplate.setExchange(PropertyLoader.MQ_EXCHANGE);
    directTemplate.setReplyTimeout(outTimeMillis);

    Message reply=directTemplate.sendAndReceive(topicRoutingKey,message);
    if(reply==null){
        throw new Exception("waitting rabbitmq response timeout");
    }
    String body=new String(reply.getBody(),"UTF-8");
    Map<String,Object> reqMsgMap =JSON.parseObject(body,new TypeReference<Map<String, Object>>(){});
    LOG.info("back :"+reqMsgMap);
    reqMsgMap =JSON.parseObject(reqMsgMap.get("mqbody").toString(),new TypeReference<Map<String, Object>>(){});
    return reqMsgMap;
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
@Test
public void testDefaultRabbitConfiguration() {
	load(TestConfiguration.class);
	RabbitTemplate rabbitTemplate = this.context.getBean(RabbitTemplate.class);
	RabbitMessagingTemplate messagingTemplate = this.context
			.getBean(RabbitMessagingTemplate.class);
	CachingConnectionFactory connectionFactory = this.context
			.getBean(CachingConnectionFactory.class);
	DirectFieldAccessor dfa = new DirectFieldAccessor(connectionFactory);
	RabbitAdmin amqpAdmin = this.context.getBean(RabbitAdmin.class);
	assertThat(rabbitTemplate.getConnectionFactory()).isEqualTo(connectionFactory);
	assertThat(getMandatory(rabbitTemplate)).isFalse();
	assertThat(messagingTemplate.getRabbitTemplate()).isEqualTo(rabbitTemplate);
	assertThat(amqpAdmin).isNotNull();
	assertThat(connectionFactory.getHost()).isEqualTo("localhost");
	assertThat(dfa.getPropertyValue("publisherConfirms")).isEqualTo(false);
	assertThat(dfa.getPropertyValue("publisherReturns")).isEqualTo(false);
	assertThat(this.context.containsBean("rabbitListenerContainerFactory"))
			.as("Listener container factory should be created by default").isTrue();
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
@Override
public Spy spyOn(final String queue) {
	final RabbitTemplate template = new RabbitTemplate(this.rabbitAvailableRule.getResource());
	template.setAfterReceivePostProcessors(new DelegatingDecompressingPostProcessor());
	return new Spy() {

		@Override
		public Object receive(boolean expectNull) throws Exception {
			if (expectNull) {
				Thread.sleep(50);
				return template.receiveAndConvert(new RabbitConsumerProperties().getPrefix() + queue);
			}
			Object bar = null;
			int n = 0;
			while (n++ < 100 && bar == null) {
				bar = template.receiveAndConvert(new RabbitConsumerProperties().getPrefix() + queue);
				Thread.sleep(100);
			}
			assertThat(n).isLessThan(100).withFailMessage("Message did not arrive in RabbitMQ");
			return bar;
		}

	};
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
@Test
public void testDefaultRabbitConfiguration() {
	load(TestConfiguration.class);
	RabbitTemplate rabbitTemplate = this.context.getBean(RabbitTemplate.class);
	RabbitMessagingTemplate messagingTemplate = this.context
			.getBean(RabbitMessagingTemplate.class);
	CachingConnectionFactory connectionFactory = this.context
			.getBean(CachingConnectionFactory.class);
	RabbitAdmin amqpAdmin = this.context.getBean(RabbitAdmin.class);
	assertEquals(connectionFactory, rabbitTemplate.getConnectionFactory());
	assertEquals(rabbitTemplate, messagingTemplate.getRabbitTemplate());
	assertNotNull(amqpAdmin);
	assertEquals("localhost", connectionFactory.getHost());
	assertTrue("Listener container factory should be created by default",
			this.context.containsBean("rabbitListenerContainerFactory"));
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
@Override
public AmqpTemplate getObject() throws Exception {
    RabbitTemplate rabbitTemplate = rabbitAdmin.getRabbitTemplate();
    rabbitTemplate.setMessageConverter(messageConverter);
    rabbitTemplate.setRetryTemplate(retryTemplate());

    if (messagingConfiguration.isMandatoryMessages()) {
        logger.info("will send mandatoryMessages, which expect at least one consumer");

        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(createReturnCallback());
    } else {
        logger.info("mandatory flag is not set, messages are not being set as mandatory");
    }

    return rabbitTemplate;
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
private RabbitTemplate.ReturnCallback createReturnCallback() {
    return new RabbitTemplate.ReturnCallback() {
        @Override
        public void returnedMessage(final Message message, final int replyCode, final String replyText, final String exchange,
                                    final String routingKey) {
            try {
                byte[] correlationFromMessage = message.getMessageProperties().getCorrelationId();
                UniqueId uniqueId = uniqueIdFactory.fromBytes(correlationFromMessage);
                logger.warn("exchange: [ {} ], routingKey: [ {} ], there is no consumer defined to consume [ {} ]", exchange,
                            routingKey, message);
                responseListener.notifyWithError(uniqueId, new RuntimeException("no listener for message"));
            } catch (Exception e) {
                logger.warn("for message {}, replyCode {}, replyText, exchange, routingKey", message, replyCode, replyText, exchange,
                            routingKey);
                logger.warn("something is wrong while processing return callback", e);
            }
        }
    };
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
private void replyIfNecessary(Message message, Object result, RabbitTemplate mqTemplate) {
	MessageProperties messageProperties = message.getMessageProperties();
	String correlationId = null;
	try {
		correlationId = new String(messageProperties.getCorrelationId(), DEFAULT_CHARSET);
	} catch (Exception ignored) {
		try {
			correlationId = (String) SerializationUtils.deserialize(messageProperties.getCorrelationId());
		} catch (Exception warnException) {
			LogUtil.warn(logger, "#####获取correlationId失败，可能导致客户端挂起", warnException);
		}
	}
	boolean isNecessary = result != null && messageProperties.getReplyTo() != null;
	if (isNecessary) {
		mqTemplate.send(messageProperties.getReplyTo(), correlationId == null ? mqMessageConverter.toSendMessage(result) : mqMessageConverter.toReplyMessage(result, correlationId));
	}
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
public static void main(String[] args) throws Exception
{
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

    // invoke the CONFIG
    /*
     * application context then starts the message listener container, and
     * the message listener container bean starts listening for messages
     */
    ctx.register(RabbitMQConfig.class);
    ctx.refresh();
    
    RabbitTemplate rabbitTemplate = ctx.getBean(RabbitTemplate.class);

    System.out.println("* Waiting 3 seconds...");
    Thread.sleep(3000);
    System.out.println("* Sending message...");
    
    rabbitTemplate.convertAndSend(queueName, "* Hello from RabbitMQ!");

    System.exit(0);
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <T> T createProxy(Class<T> clazz, int timeout) {
	RabbitTemplate rabbitTemplate = RabbitConfiguration.rabbitTemplate();
	if (rabbitTemplate == null) {
		throw new RuntimeException("��Ϣ�������Ѿ�崻�������ϵ����Ա��");
	}
	AmqpProxyFactoryBean amqpProxyFactoryBean = new AmqpProxyFactoryBean();
	amqpProxyFactoryBean.setAmqpTemplate(rabbitTemplate);
	amqpProxyFactoryBean.setServiceInterface(clazz);
	amqpProxyFactoryBean.afterPropertiesSet();
	amqpProxyFactoryBean.setRemoteInvocationFactory(new SimpleRemoteInvocationFactory());

	Object springOrigProxy = createProxy(amqpProxyFactoryBean);
	RabbitMethodInterceptor methodInterceptor = new RabbitMethodInterceptor(timeout);

	ProxyFactory factory = new ProxyFactory();
	factory.addAdvisor(new DefaultPointcutAdvisor(Pointcut.TRUE, methodInterceptor));
	factory.setProxyTargetClass(false);
	factory.addInterface(clazz);
	factory.setTarget(springOrigProxy);
	return (T) factory.getProxy();

}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
/**
 * Constructor
 * @param rabbitTemplate Rabbit Template
 * @param ticketServiceResponseExchange Event Exchange
 */
public TicketingServiceProducerImpl(final RabbitTemplate rabbitTemplate, final Exchange ticketServiceResponseExchange)
{
    this.ticketServiceResponseExchange = ticketServiceResponseExchange;
    this.rabbitTemplate = rabbitTemplate;
 
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
/**
 * This returns the RabbitMQ template.
 *
 * @return The RabbitMQ template.
 */
@Bean
RabbitTemplate rabbitTemplate()
{
    final RabbitTemplate template = new RabbitTemplate(rabbitConnectionFactory);
    template.setMessageConverter(messageConverter());
    template.setRetryTemplate(retryTemplate());
    return template;
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
private String getExchangeFromRabbitTemplate(Object target) {
  String exchange = null;
  if (target instanceof RabbitTemplate) {
    exchange = ((RabbitTemplate) target).getExchange();
  }
  return exchange;
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
@Bean
@ConditionalOnSingleCandidate(ConnectionFactory.class)
@ConditionalOnMissingBean(RabbitTemplate.class)
public RabbitTemplate rabbitTemplate() {
    RabbitTemplate template = new RabbitTemplate(connectionFactory);
    RetryTemplate retryTemplate = new RetryTemplate();
    ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
    backOffPolicy.setInitialInterval(500);
    backOffPolicy.setMultiplier(10.0);
    backOffPolicy.setMaxInterval(10000);
    retryTemplate.setBackOffPolicy(backOffPolicy);
    template.setRetryTemplate(retryTemplate);
    template.setMessageConverter(messageConverter);
    return template;
}
 

import org.springframework.amqp.rabbit.core.RabbitTemplate; //导入依赖的package包/类
@Bean
@Autowired
public RabbitTemplate commandBusRabbitTemplate(final ConnectionFactory commandBusConnectionFactory, final MessageConverter commandBusMessageConverter) {

    log.info("Creating command bus RabbitMQ template with a custom JSON converter");
    final RabbitTemplate rabbitTemplate = new RabbitTemplate(commandBusConnectionFactory);
    rabbitTemplate.setMessageConverter(commandBusMessageConverter);

    return rabbitTemplate;
}