消息中间件之ActiveMQ整合Spring实现邮箱发送（四）

最新推荐文章于 2019-12-30 10:30:05 发布

开源项目LibraPlatform

最新推荐文章于 2019-12-30 10:30:05 发布

阅读量3.4k

点赞数 1

分类专栏：消息中间件 ActiveMQ spring 文章标签：消息中间件 activemq 电子邮件 spring

本文链接：https://blog.csdn.net/qq_33524158/article/details/78682696

版权

spring 同时被 3 个专栏收录

7 篇文章 0 订阅

订阅专栏

消息中间件

5 篇文章 1 订阅

订阅专栏

ActiveMQ

5 篇文章 0 订阅

订阅专栏

前言

前面几篇文章介绍了ActiveMQ的使用，今天来点实际的使用ActiveMQ整合Spring实现异步邮箱发送。在讲之前先提两个问题，第一个问题ActiveMQ是如何与Spring整合的？第二个问题又是这样实现异步发送电子邮件的？好！带着这两个问题来看下面代码。

实现模型图：
这里写图片描述

工程目录：

这里写图片描述

分为两个项目一个为生产端（ActiveMQ-Provider）、一个为消费端（ActiveMQ-Consumer）。数据格式采用json，使用alibaba的fastjson来做格式转换。通过Spring提供的组件来实现邮箱发送。好废话不多说，上代码。

使用maven创建项目

我是使用idea开发工具来进行开发的，如何创建maven 我就不多介绍了。

创建好项目之后在你两个项目中的pom.xml文件中加入依赖，如下：

<!--activemq-->
<dependency>
  <groupId>org.apache.activemq</groupId>
  <artifactId>activemq-all</artifactId>
  <version>5.11.1</version>
</dependency>
<dependency>
  <groupId>org.apache.activemq</groupId>
  <artifactId>activemq-pool</artifactId>
  <version>5.11.1</version>
</dependency>

<!--spring jms-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jms</artifactId>
  <version>4.3.7.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-oxm</artifactId>
  <version>4.3.7.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>4.3.7.RELEASE</version>
</dependency>

<!-- 返回json字符串的支持 -->
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.8.8</version>
</dependency>


<!--Spring-test -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>4.3.7.RELEASE</version>
</dependency>


<!-- Spring面向切面编程 -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>4.3.7.RELEASE</version>
</dependency>


<!-- （jstl，servlet-api，junit） -->
<!-- https://mvnrepository.com/artifact/jstl/jstl -->
<dependency>
  <groupId>jstl</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>


<!-- alibaba fastjson-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.1.26</version>
</dependency>

<!-- junit -->
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.12</version>
</dependency>

生产端（ActiveMQ-Provider）

因为涉及到Spring，个人习惯我先从Spring配置文件入手。

先准备一些参数文件，创建一个config.properties，内容如下：

# ActiveMQ Config
activemq.brokerURL=tcp\://192.168.0.106\:61616
activemq.userName=hfbin
activemq.password=hfbin
activemq.pool.maxConnections=10

#queueName
activemq.queueName=mailqueue

这里主要是配置ActiveMQ的一些配置参数路径、用户名、密码、线程池数量、队列名。

打印日记用的log4j.properties配置如下：

log4j.rootLogger=INFO, console, file

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.file.File=D:/acmq.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.logger.org.springframework=WARN

spring-context.xml配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-3.2.xsd"
    default-autowire="byName" default-lazy-init="false">

    <!-- 读入配置属性文件 -->
    <context:property-placeholder location="classpath:config.properties" />

    <!-- 注释配置 -->
    <context:annotation-config />

    <!-- 自动扫描包起始位置 -->
    <context:component-scan base-package="cn.hfbin" />

    <!-- 加入spring与ActiveMQ整合配置文件-->
    <import resource="classpath:spring-activemq.xml" />
</beans>

每一行代码我都做有注释，我在这不做过多的说明。

下面介绍的才是今天主题的重点就是如何实现Spring与ActiveMQ整合。

spring-activemq.xml配置文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-3.2.xsd"
    default-autowire="byName" default-lazy-init="false">

    <!-- 第三方MQ工厂: ConnectionFactory -->
    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <!-- ActiveMQ Address -->
        <property name="brokerURL" value="${activemq.brokerURL}" />
        <property name="userName" value="${activemq.userName}"></property>
        <property name="password" value="${activemq.password}"></property> 
    </bean>

    <!-- 
        ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory
        可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗,要依赖于 activemq-pool包
     -->
    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
        <property name="connectionFactory" ref="targetConnectionFactory" />
        <property name="maxConnections" value="${activemq.pool.maxConnections}" />
    </bean>

    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
        <property name="targetConnectionFactory" ref="pooledConnectionFactory" />
    </bean>

    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
    <!-- 队列模板 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
        <property name="connectionFactory" ref="connectionFactory"/>  
        <property name="defaultDestinationName" value="${activemq.queueName}"></property>
    </bean> 

</beans>

每一行代码我都做有注释，在这我就简单说明一下，在spring-context.xml文件中我们已经导入过config.properties，在这个文件里我们就不用重复的去导入了。这些都是固定的写法，没有什么技巧，记得哪一步到哪一步就好。好这就是Spring与ActiveMQ整合。所有的关于spring配置的文件都讲完了，下面就进行实现生产数据的代码。

首先先创建一个实体类Mail：

public class Mail {

    /** 发件人 **/
    private String from;
    /** 收件人 **/
    private String to;
    /** 主题 **/
    private String subject;
    /** 邮件内容 **/
    private String content;

    public Mail(){}

    public Mail(String from, String to, String subject, String content) {
        super();
        this.from = from;
        this.to = to;
        this.subject = subject;
        this.content = content;
    }

    public String getFrom() {
        return from;
    }
    public void setFrom(String from) {
        this.from = from;
    }
    public String getTo() {
        return to;
    }
    public void setTo(String to) {
        this.to = to;
    }
    public String getSubject() {
        return subject;
    }
    public void setSubject(String subject) {
        this.subject = subject;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}

实现生产数据的代码如下 MQProducer：


@Service()
public class MQProducer {

    @Autowired
    private JmsTemplate jmsTemplate;

    public void sendMessage(final Mail mail) {
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(JSONObject.toJSONString(mail));
            }
        });
    }
}

这里的代码非常简单，整合spring后什么数据都在配置文件创建好了，与之前直接写ActiveMQ实现数据生产的方法差别就是天地之大。这里只需要注入jmsTemplate，使用send方法即可实现数据发送。注意这里使用fastjson将实体类数据转换成json字符串了。

既然实现生产数据的也写好了那就差一个测试类了，项目是maven创建的，使用idea创建maven项目是没有test测试的文件，在这我就自己创建了，新建一个类TestProducer，代码如下：


@ContextConfiguration(locations = {"classpath:spring-context.xml" })
@RunWith(SpringJUnit4ClassRunner.class)
public class TestProducer {

    @Autowired
    private MQProducer mqProducer;

    @Test
    public void send(){
        Mail mail = new Mail();
        mail.setTo("1716850375@qq.com");
        mail.setSubject("异步发送邮件");
        mail.setContent("Hello,This is a message!");

        this.mqProducer.sendMessage(mail);
        System.out.println("发送成功  >>>  "+ mail.getTo());
    }

}

这里使用到了spring的测试工具
@ContextConfiguration(locations = {“classpath:spring-context.xml” }) 加载spring文件路径

@RunWith(SpringJUnit4ClassRunner.class) 使用spring提供的测试工具。

这里需要注入我们刚刚写好的生产数据的类，然后传入Mail数据调用sendMessage（）方法既可以实现生产数据。

我运行这个测试方法：

到浏览器查看我的ActiveMQ Web端，如图：

这里写图片描述

从图可看出我们已经成功生产一条数据了。

到这生产端代码编写完成！！！

消费端及其实现发邮箱（ActiveMQ-Consumer）

这里spring配置很多都跟消费端的一样，我就直接复制了（config.properties、log4j.properties、spring-activemq.xml、spring-context.xml），好下面我只对更改部分做说明：

config.properties原先只是配置了ActiveMQ的相关信息，现在要加多一下内容：

## SMTP Configuration  我这里使用的是qq
#主机
mail.host=smtp.qq.com
##mail.port=21
#你发送的邮箱
mail.username=1340287013@qq.com 
#你邮箱的密码
mail.password=******
#是否开启认证
mail.smtp.auth=true
#超时
mail.smtp.timeout=30000
#你发送的邮箱
mail.default.from=1340287013@qq.com

这里的数据主要是为了后面我们实现发送邮箱用的。

log4j.properties这个不变。

spring-context.xml这里加多如下内容：


<!-- proxy-target-class默认"false",更改为"ture"使用CGLib动态代理 -->
<aop:aspectj-autoproxy proxy-target-class="true" /> 

<!--引入发送邮箱的配置-->
<import resource="classpath:spring-mail.xml" />

这里spring-mail.xml我后面会说。

spring-activemq.xml在后面加入下面内容：


<!--这个是目的地:mailQueue -->
<bean id="mailQueue" class="org.apache.activemq.command.ActiveMQQueue">
    <constructor-arg>
        <value>${activemq.queueName}</value>
    </constructor-arg>
</bean>
<!-- 配置自定义监听：MessageListener -->
<bean id="mailQueueMessageListener" class="cn.hfbin.mq.MailQueueMessageListener"></bean>

<!-- 将连接工厂、目标对了、自定义监听注入jms模板 -->
<bean id="sessionAwareListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="connectionFactory" />
    <property name="destination" ref="mailQueue" />
    <property name="messageListener" ref="mailQueueMessageListener" />
</bean>

这些都是一些固定的配置，注意这里我设置了自定义的监听类MailQueueMessageListener，只要我们spring启动这个类就会被执行。

好！到这复制的文件就改动到这，下面来看一下实现发邮箱的spring配置即spring-mail.xml，内容如下：

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
       http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.2.xsd">


    <!-- Spring提供的发送电子邮件的高级抽象类 -->
    <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
        <property name="host" value="${mail.host}" />
        <property name="username" value="${mail.username}" />
        <property name="password" value="${mail.password}" />
        <property name="defaultEncoding" value="UTF-8"></property>
        <property name="javaMailProperties">
            <props>
                <prop key="mail.smtp.auth">${mail.smtp.auth}</prop>
                <prop key="mail.smtp.timeout">${mail.smtp.timeout}</prop>
            </props>
        </property>
    </bean>

    <bean id="simpleMailMessage" class="org.springframework.mail.SimpleMailMessage">
        <property name="from">
            <value>${mail.default.from}</value>
        </property>
    </bean>

    <!-- 配置线程池 -->
    <bean id="threadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 线程池维护线程的最少数量 -->
        <property name="corePoolSize" value="5" />
        <!-- 线程池维护线程所允许的空闲时间 -->
        <property name="keepAliveSeconds" value="30000" />
        <!-- 线程池维护线程的最大数量 -->
        <property name="maxPoolSize" value="50" />
        <!-- 线程池所使用的缓冲队列 -->
        <property name="queueCapacity" value="100" />
    </bean>

</beans>

spring提供了一个高级类JavaMailSenderImpl，这里只需要配置一些参数值就好。还有spring也提供了线程池，不需要我们另外创建，这里直接加入就好，到时候使用直接注入使用即可。

到这spring所以有配置文件已经完成，下面来干点实际的如何消费我们生产端的数据，然后实现邮箱发送。

实体类Mail还是一样直接复制生产端Mail就好了。

刚刚在上面文件提到了，自己创建一个监听类MailQueueMessageListener这里要实现SessionAwareMessageListener接口里面的onMessage()方法，该方法相当于获取生产端队列中的数据，代码如下：

@Component
public class MailQueueMessageListener implements SessionAwareMessageListener<Message> {

    @Autowired
    private JmsTemplate jmsTemplate;
    @Autowired
    private Destination mailQueue;
    @Autowired
    private MailService mailService;

    public synchronized void onMessage(Message message, Session session) {

        try {
            TextMessage msg = (TextMessage) message;
            final String ms = msg.getText();

            //转换成相应的对象
            Mail mail = JSONObject.parseObject(ms, Mail.class);
            System.out.println("收到消息：" + mail);
            if (mail == null) {
                return;
            }
            try {
                //执行发送业务
                mailService.mailSend(mail);

            } catch (Exception e) {
                // 发送异常，重新放回队列
                jmsTemplate.send(mailQueue, new MessageCreator() {
                    public Message createMessage(Session session) throws JMSException {
                        return session.createTextMessage(ms);
                    }
                });
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这里通过fastjson将json数据格式转换为实体类Mail，也注入MailService实现发邮箱业务逻辑的类，如果出现异常这里也将会将数据重新放回队列。

下面说说是如何实现发邮箱的MailService类，代码如下：

@Service()
public class MailService {

    @Autowired
    private JavaMailSender mailSender;
    @Autowired
    private SimpleMailMessage simpleMailMessage;
    @Autowired
    private ThreadPoolTaskExecutor threadPool;

    /**
     * @param mail
     */
    public void mailSend(final Mail mail) {
        threadPool.execute(new Runnable() {
            public void run() {
                try {
                    //发送人
                    simpleMailMessage.setFrom(simpleMailMessage.getFrom());
                    //收件者
                    simpleMailMessage.setTo(mail.getTo()); 

                    simpleMailMessage.setSubject(mail.getSubject());
                    //发送的信息
                    simpleMailMessage.setText(mail.getContent());
                    mailSender.send(simpleMailMessage);
                } catch (MailException e) {
                    e.printStackTrace();
                    throw e;
                }
            }
        });
    }
}

这里使用到了线程池来执行，在spring里我们已经做了配置，在这里只需要注入即可使用。通过SimpleMailMessage来设置发送邮箱的参数，使用JavaMailSender的send()方法实现发送。

到这目前都讲完了是不是觉得很简单，大多数都是固定的写法。

好！到这讲完了现在写一个，启动spring的类，在这我不使用跟生产端的那种方式了，因为这里我配置了监听类只要启动spring，整个程序就会跑起来了，代码如下：


public class TestConsumer {

    public static void main(String[] args) {
        try {
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "spring-context.xml" });
            context.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}