Java简单使用Rabbitmq

1.导入pom

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>

package com.chem.www.service.impl;

import com.chem.www.domain.Notice;
import com.chem.www.domain.NoticeMail;
import com.chem.www.domain.NoticeMailMessageConverter;
import com.chem.www.domain.NoticeRowFile;
import com.chem.www.service.NoticeService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.stereotype.Service;

import javax.annotation.PreDestroy;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
@RequiredArgsConstructor
@Service("noticeService")
public class RabbitNoticeService implements NoticeService {
    private static final ExecutorService EXECUTOR = Executors.newSingleThreadExecutor();
    private static final String MAIL_EXCHANGE = "mce.mail";
    private static final String ROW_FILE_EXCHANGE = "mce.row-file";

    private final RabbitTemplate rabbitTemplate;
    private final MessageConverter messageConverter = new Jackson2JsonMessageConverter();
    private final NoticeMailMessageConverter mailMessageConverter = new NoticeMailMessageConverter();

    /**
     * 在开发中我们如果要在关闭spring容器后释放一些资源,通常的做法有如下几种:
     * 1.在方法上加上@PreDestroy注解
     * 2.实现DisposableBean接口,实现其destroy方法
     */
    @PreDestroy
    public void shutdown() {
        EXECUTOR.shutdown();
    }

    @Override
    public void send(Notice notice) {
        EXECUTOR.execute(() -> {
            try {
                /**
                 * 将Java对象转换为消息。
                 * 参数：
                 * object -要转换消息的对象Properties-消息属性。
                 * 退货：
                 * 消息抛出：
                 * MessageConversionException -在转换失败时
                 */
                rabbitTemplate.send(messageConverter.toMessage(notice, new MessageProperties()));
            } catch (Exception e) {
                log.error("RabbitNoticeService.send(Notice)", e);
            }
        });
    }

    @Override
    public void mail(NoticeMail noticeMail) {
        EXECUTOR.execute(() -> {
            try {
                /**
                 * RabbitMQ 消息传递模型的核心思想是：生产者生产的消息从来不会直接发送到队列。实际上，通常生产者都不知道这些消息发送到了哪些队列中。
                 * 相反，生产者只能将消息发送到交换机（exchange）。交换机的工作内容非常简单，一方面它接受来自生产者的消息，另一方面将这些消息推入队列。
                 * 交换机必须知道如何处理收到的消息。是应该把这些消息放入特定队列还是说放到许多队列，或者直接丢弃，这就由交换机的类型决定。
                 */
                //发送
                rabbitTemplate.send(MAIL_EXCHANGE, "", mailMessageConverter.toMessage(noticeMail, new MessageProperties()));

            } catch (Exception e) {
                log.error("RabbitNoticeService.mail", e);
            }
        });
    }

    @Override
    public void extractRowFile(NoticeRowFile noticeRowFile) {
        if (noticeRowFile == null) {
            return;
        }
        EXECUTOR.execute(() -> {
            try {
                rabbitTemplate.send(ROW_FILE_EXCHANGE, "", messageConverter.toMessage(noticeRowFile, new MessageProperties()));
            } catch (Exception e) {
                log.error("RabbitNoticeService.extractRowFile", e);
            }
        });
    }
}

package com.chem.www.domain;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.support.converter.AbstractMessageConverter;
import org.springframework.amqp.support.converter.MessageConversionException;

public class NoticeMailMessageConverter extends AbstractMessageConverter {
    @Override
    protected Message createMessage(Object object, MessageProperties messageProperties) {
        if (object instanceof NoticeMail) {
            var notice = (NoticeMail) object;
            var bs = notice.toBytes();
            return new Message(bs, messageProperties);
        }
        return null;
    }

    @Override
    public Object fromMessage(Message message) throws MessageConversionException {
        return null;
    }
}

使用：

 noticeService.send(Notice.error("MCE::save user order", e.getMessage()));

package com.chem.www.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
public class Notice {
    private Channel channel;
    private String title;
    private String text;

    public Notice() {
    }

    public Notice(Channel channel, String title, String text) {
        this.channel = channel;
        this.title = title;
        this.text = text;
    }

    public static Notice info(String title, String text) {
        return new Notice(Channel.MCE_DEBUG, title, text);
    }

    public static Notice error(String title, String text) {
        return new Notice(Channel.MCE_ERROR, title, text);
    }

    public static Notice erpError(String title, String text) {
        return new Notice(Channel.ERP_ERROR, title, text);
    }

    public enum Channel {
        MCE_DEVELOP,
        MCE_DEBUG,
        MCE_ERROR,

        ERP_ERROR,
        ;
    }
}