rabbitMQ配置spring boot

package rabbitmq.config;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;


import rabbitmq.linstener.ConfirmCallBackListener;
import rabbitmq.linstener.ReturnCallBackListener;


@Configuration
public class RabbitConfig {

private static final Logger logger = LoggerFactory.getLogger(RabbitConfig.class);


public static final String TIMER_EXCHANGE = "exchange.timer";
public static final String TIMER_ROUTINGKEY = "routingkey.timer";
public static final String TIMER_QUEUE = "timer";


@Autowired
private ConfirmCallBackListener confirmCallback;

@Autowired
private ReturnCallBackListener returnCallback;


@Value("${rabbitmq.host}")
private String host;


@Value("${rabbitmq.port}")
private Integer port;


@Value("${rabbitmq.username}")
private String username;


@Value("${rabbitmq.password}")
private String password;


@Value("${rabbitmq.publisher-confirms}")
private boolean publisherConfirms;


@Value("${rabbitmq.virtual-host}")
private String virtualHost;


@Bean
public ConnectionFactory connectionFactory() {
CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
connectionFactory.setAddresses(host);
connectionFactory.setPort(port);
connectionFactory.setUsername(username);
connectionFactory.setPassword(password);
connectionFactory.setVirtualHost(virtualHost);
// 如果要进行消息回调，则这里必须要设置为true 
connectionFactory.setPublisherConfirms(publisherConfirms);
return connectionFactory;
}



//因为要设置回调类，所以应是prototype类型，如果是singleton类型，则回调类为最后一次设置 
@Bean
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public RabbitTemplate rabbitTemplate() {
RabbitTemplate template = new RabbitTemplate(connectionFactory());
template.setConfirmCallback(confirmCallback);
template.setReturnCallback(returnCallback);
return template;
}

// 设置消息队列
@Bean
public Queue helloQueue() {
return new Queue(TIMER_QUEUE);
}


// 设置交换机类型
@Bean
public DirectExchange defaultExchange() {
// DirectExchange:按照routingkey分发到指定队列
// TopicExchange:多关键字匹配
// FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念
// HeadersExchange ：通过添加属性key-value匹配
return new DirectExchange(TIMER_EXCHANGE);
}


@Bean
public Binding binding() {
// 将队列绑定到交换机
return BindingBuilder.bind(helloQueue()).to(defaultExchange()).with(TIMER_ROUTINGKEY);
}

}

package rabbitmq.test2;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;


@SpringBootApplication
@ComponentScan(basePackages={"rabbitmq.config","rabbitmq.test2","rabbitmq.linstener"}) 
public class HelloApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class, args);
    }
    
}

package rabbitmq.test2;


import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@SpringApplicationConfiguration(classes = HelloApplication.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class HelloApplicationTests {
    @Autowired
    private Sender sender;
    @Test
    public void hello() throws Exception {
        for (int i = 0; i < 100; i++) {
        sender.send(i);
}
    }
}

package rabbitmq.test2;


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


@Component
public class Receiver2 {
   
@RabbitListener(queues = "timer")
@RabbitHandler
    public void process(String hejie) {
        System.out.println("Receiver消费者 222: " + hejie);
    }
}

package rabbitmq.test2;


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


@Component
public class Receiver {

    @RabbitHandler
    @RabbitListener(queues = "timer")
    public void process(String hejie) {
        System.out.println("Receiver消费者 : " + hejie);
    }
}

package rabbitmq.test2;


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(int i) {
String context = "hello RabbitMQ ";
System.out.println("Sender : " + context+"----------"+i);
rabbitTemplate.convertAndSend("timer", context);
}

}

package rabbitmq.message;


import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class RabbitMessage implements Serializable {


private static final long serialVersionUID = 8361073872299677488L;

private Class[] paramTypes;// 参数类型

private String exchange;// 交换器


private Object[] params;


private String routeKey;// 路由key


public RabbitMessage() {
}


public RabbitMessage(String exchange, String routeKey, Object... params) {
this.params = params;
this.exchange = exchange;
this.routeKey = routeKey;
}


@SuppressWarnings("rawtypes")
public RabbitMessage(String exchange, String routeKey, String methodName, Object... params) {
this.params = params;
this.exchange = exchange;
this.routeKey = routeKey;
int len = params.length;
Class[] clazzArray = new Class[len];
for (int i = 0; i < len; i++)
clazzArray[i] = params[i].getClass();
this.paramTypes = clazzArray;
}


public byte[] getSerialBytes() {
byte[] res = new byte[0];
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos;
try {
oos = new ObjectOutputStream(baos);
oos.writeObject(this);
oos.close();
res = baos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}
return res;
}


public String getRouteKey() {
return routeKey;
}


public String getExchange() {
return exchange;
}


public void setExchange(String exchange) {
this.exchange = exchange;
}


public void setRouteKey(String routeKey) {
this.routeKey = routeKey;
}


public Class[] getParamTypes() {
return paramTypes;
}


public Object[] getParams() {
return params;
}


}

package rabbitmq.linstener;


import org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.stereotype.Component;


@Component
public class ConfirmCallBackListener implements ConfirmCallback {


@Override
public void confirm(CorrelationData arg0, boolean arg1, String arg2) {
// 只确认生产者消息发送成功，消费者是否处理成功不做保证

System.out.println("确认消息完成...");
}


}

package rabbitmq.linstener;


import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate.ReturnCallback;
import org.springframework.stereotype.Component;


@Component
public class ReturnCallBackListener implements ReturnCallback {


@Override
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
System.out.println("消息返回处理中...");
}

}

package rabbitmq.linstener;


import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;


import com.rabbitmq.client.Channel;


public class ReceiveConfirmTestListener implements ChannelAwareMessageListener {


@Override
public void onMessage(Message message, Channel channel) throws Exception {
try {
System.out.println("consumer--:" + message.getMessageProperties() + ":" + new String(message.getBody()));


// deliveryTag是消息传送的次数，我这里是为了让消息队列的第一个消息到达的时候抛出异常，处理异常让消息重新回到队列，然后再次抛出异常，处理异常拒绝让消息重回队列
if (message.getMessageProperties().getDeliveryTag() == 1
|| message.getMessageProperties().getDeliveryTag() == 2) {
throw new Exception();
}


channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); // false只确认当前一个消息收到，true确认所有consumer获得的消息
} catch (Exception e) {
e.printStackTrace();


if (message.getMessageProperties().getRedelivered()) {
System.out.println("消息已重复处理失败,拒绝再次接收...");
channel.basicReject(message.getMessageProperties().getDeliveryTag(), true); // 拒绝消息
} else {
System.out.println("消息即将再次返回队列处理...");
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true); // requeue为是否重新回到队列
}
}
}


}