簡介

上一篇文章說的是應用之間同步進行互動的場景，這裡介紹非同步的使用。

概念

同步，當客戶端呼叫遠端方法時，客戶端必須等待遠端方法完成之後，才能繼續執行，即使遠端方法並不返回任何訊息，客戶端也必須阻塞到服務完成。
非同步，客戶端不需要等待伺服器處理訊息，甚至不需要等待客戶端把訊息傳送給了服務端，就可以繼續執行後面的流程，這是因為客戶端假定服務端最終可以收到並處理這條訊息。

傳送訊息

在非同步訊息中主要有兩個概念：訊息代理和目的地。
當一個應用傳送訊息時，會將訊息交給一個訊息代理，訊息代理類似郵局。訊息代理可以確保訊息被投遞到指定的目的地，目的地類似於郵筒。同時解放傳送者，使傳送者能夠繼續進行其他業務。

兩種通用的 目的地：佇列和主題。
佇列：點對點模型

訊息傳送  -- 》 佇列  --》接收者

主題：釋出-訂閱模型

                            訂閱者A
訊息傳送 -- > 主題   -->      訂閱者B
                            訂閱者C

使用jms傳送訊息基於activeMQ

Java訊息服務（Java message service，JMS）是一個Java標準，定義了使用訊息代理的通用API。
spring基於模板的抽象為JMS功能提供了支援，這個模板就是 jmstemplate。使用jmstemplate，能夠非常容易地在訊息生產方傳送佇列和主題，在接收方也非常容易接收訊息。
但是傳送訊息還需要一個訊息代理，這裡採用activeMQ。

在spring中搭建訊息代理

解壓到D盤

啟動訊息代理 開啟這個bat檔案
D:\apache-activemq-5.14.3\bin\win64\activemq.bat

建立連線工廠

ConnectionFactory是用於產生到JMS伺服器的連結的，Spring為我們提供了多個ConnectionFactory，有SingleConnectionFactory和CachingConnectionFactory。SingleConnectionFactory對於建立JMS伺服器連結的請求會一直返回同一個連結，並且會忽略Connection的close方法呼叫。CachingConnectionFactory繼承了SingleConnectionFactory，所以它擁有SingleConnectionFactory的所有功能，同時它還新增了快取功能，它可以快取Session、MessageProducer和MessageConsumer。

<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory"/>  

Spring提供的ConnectionFactory只是Spring用於管理ConnectionFactory的，真正產生到JMS伺服器連結的ConnectionFactory還得是由JMS服務廠商提供，並且需要把它注入到Spring提供的ConnectionFactory中。我們這裡使用的是ActiveMQ實現的JMS，所以在我們這裡真正的可以產生Connection的就應該是由ActiveMQ提供的ConnectionFactory。所以定義一個ConnectionFactory的完整程式碼應該如下所示

<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
    <property name="brokerURL" value="tcp://192.168.7.234:61616"/>  
</bean>  

<!-- Spring用於管理真正的ConnectionFactory的ConnectionFactory -->  
<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
    <!-- 目標ConnectionFactory對應真實的可以產生JMS Connection的ConnectionFactory -->  
    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
</bean>  

ActiveMQ為我們提供了一個PooledConnectionFactory，通過往裡面注入一個ActiveMQConnectionFactory可以用來將Connection、Session和MessageProducer池化，這樣可以大大的減少我們的資源消耗。當使用PooledConnectionFactory時，我們在定義一個ConnectionFactory時應該是如下配置

<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory" ref="pooledConnectionFactory"/>
</bean> 

<bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">  
        <property name="connectionFactory" ref="targetConnectionFactory"/>  
        <property name="maxConnections" value="10"/>  
</bean> 

<bean id="targetConnectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://192.168.7.234:61616"/>
</bean>

配置生產者

生產者負責產生訊息併發送到JMS伺服器
利用Spring為我們提供的JmsTemplate類來處理訊息傳送 對於訊息傳送者而言，它在傳送訊息的時候要知道自己該往哪裡發，為此，我們在定義JmsTemplate的時候需要往裡面注入一個Spring提供的ConnectionFactory物件

<!-- Spring提供的JMS工具類，它可以進行訊息傳送、接收等 -->  
<bean id="senderJmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
    <!-- 這個connectionFactory對應的是我們定義的Spring提供的那個ConnectionFactory物件 -->  
    <property name="connectionFactory" ref="connectionFactory"/>  
    <!-- true/訂閱模式傳送，false/點對點的模式傳送 -->
    <property name="pubSubDomain" value="false"/>
</bean> 

配置目的地

用JmsTemplate進行訊息傳送的時候，我們需要知道訊息傳送的目的地(destination)

 <!-- 設定兩個目的地，一個是佇列形式，一個是主題模式（訂閱/釋出） -->
    <bean id="myQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 指定佇列名稱 -->
        <constructor-arg>
            <value>myQueue</value>
        </constructor-arg>
    </bean>

    <bean id="myTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <!-- 指定主題名稱 -->
        <constructor-arg>
            <value>myTopic</value>
        </constructor-arg>
    </bean>

定義傳送訊息的介面與實現類

介面類

package com.jx.spring.jms.server;

public interface AlertService {
    void sendUserMsg(User user);
}

實現類

package com.jx.spring.jms.server;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.jms.core.JmsOperations;
import org.springframework.jms.core.MessageCreator;

public class AlertServiceImpl implements AlertService{

    private JmsOperations jmsOperations;            //注入jms模板

    @Override
    public void sendUserMsg(final String dest , final String msg) {
        jmsOperations.send(             //傳送訊息
                dest,           //指定目的地
                new MessageCreator() {
                    @Override
                    public Message createMessage(Session session) throws JMSException {
                        return session.createTextMessage(msg);      //建立訊息
                    }
                }
            );
    }

    public JmsOperations getJmsOperations() {
        return jmsOperations;
    }

    public void setJmsOperations(JmsOperations jmsOperations) {
        this.jmsOperations = jmsOperations;
    }
}

為傳送訊息介面注入 生產者

    <!-- 注入AlertServiceImpl -->
    <bean id="alertService" class="com.jx.spring.jms.server.AlertServiceImpl">
        <property name="jmsOperations" ref="sendTmsTemplate"/>
    </bean>

編寫測試傳送訊息入口類

    public static void main(String[] args) {

        ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("server.xml");
        AlertServiceImpl alert = (AlertServiceImpl) cxt.getBean("alertService");
        String dest = "myQueue";
        String msg = "hello";
        alert.sendUserMsg(dest , msg);

    }

配置消費者

生產者往指定目的地Destination傳送訊息後，接下來就是消費者對指定目的地的訊息進行消費了。
消費者是如何知道有生產者傳送訊息到指定目的地Destination了呢？這是通過Spring為我們封裝的訊息監聽容器MessageListenerContainer實現的，它負責接收資訊，並把接收到的資訊分發給真正的MessageListener進行處理。每個消費者對應每個目的地都需要有對應的MessageListenerContainer。對於訊息監聽容器而言，除了要知道監聽哪個目的地之外，還需要知道到哪裡去監聽，也就是說它還需要知道去監聽哪個JMS伺服器，這是通過在配置MessageConnectionFactory的時候往裡面注入一個ConnectionFactory來實現的。所以我們在配置一個MessageListenerContainer的時候有三個屬性必須指定，一個是表示從哪裡監聽的ConnectionFactory；一個是表示監聽什麼的Destination；一個是接收到訊息以後進行訊息處理的MessageListener。
Spring一共為我們提供了兩種型別的MessageListenerContainer，SimpleMessageListenerContainer和DefaultMessageListenerContainer。
SimpleMessageListenerContainer會在一開始的時候就建立一個會話session和消費者Consumer，並且會使用標準的JMS MessageConsumer.setMessageListener()方法註冊監聽器讓JMS提供者呼叫監聽器的回撥函式。它不會動態的適應執行時需要和參與外部的事務管理。相容性方面，它非常接近於獨立的JMS規範，但一般不相容Java EE的JMS限制。
大多數情況下我們還是使用的DefaultMessageListenerContainer，跟SimpleMessageListenerContainer相比，DefaultMessageListenerContainer會動態的適應執行時需要，並且能夠參與外部的事務管理。它很好的平衡了對JMS提供者要求低、先進功能如事務參與和相容Java EE環境。

定義處理訊息的MessageListener

package com.jx.spring.jms.client;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class MyMessageListener implements MessageListener{

    @Override
    public void onMessage(Message msg) {
        TextMessage text = (TextMessage) msg;
        System.out.println("client 1 收到一條訊息");
        try {
            System.out.println(text.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

}

要定義處理訊息的MessageListener我們只需要實現JMS規範中的MessageListener介面就可以了。MessageListener介面中只有一個方法onMessage方法，當接收到訊息的時候會自動呼叫該方法

配置訊息監聽

    <bean id="myMessageListener" class="com.jx.spring.jms.client.MyMessageListener"/>

配置訊息監聽容器

這裡省略connectionFactory 、destination 這兩個需要與傳送端保持一致即可

    <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
        <property name="connectionFactory" ref="connectionFactory" />  
        <property name="destination" ref="myQueue" />
        <property name="messageListener" ref="myMessageListener" />
    </bean>

編寫接收端

public static void main(String[] args) {

        ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("client.xml");
        System.out.println("接收者1啟動");
    }

測試結果

執行傳送端測試類，與接收端測試類 (先後執行哪個端都可以)
控制檯輸出

附上完整的配置與Java類

傳送端spring配置檔案

<!-- 配置連線工廠，指定訊息代理的URL -->

    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory" ref="pooledConnectionFactory"/>
    </bean> 

    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">  
        <property name="connectionFactory" ref="targetConnectionFactory"/>  
        <property name="maxConnections" value="10"/>  
    </bean> 

    <bean id="targetConnectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://192.168.7.234:61616"/>
    </bean>


    <!-- 配置傳送者 -->
    <bean id="sendTmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
        <!-- 這個connectionFactory對應的是我們定義的Spring提供的那個ConnectionFactory物件 -->  
        <property name="connectionFactory" ref="connectionFactory"/>
        <!-- true/訂閱模式傳送，false/點對點的模式傳送 -->
        <property name="pubSubDomain" value="false"/>
    </bean>

    <!-- 設定兩個目的地，一個是佇列形式，一個是主題模式（訂閱/釋出） -->
    <bean id="myQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 指定佇列名稱-->
        <constructor-arg>
            <value>myQueue</value>
        </constructor-arg>
    </bean>

    <bean id="myTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <!-- 指定主題名稱 -->
        <constructor-arg>
            <value>myTopic</value>
        </constructor-arg>
    </bean>

    <!-- 注入AlertServiceImpl -->
    <bean id="alertService" class="com.jx.spring.jms.server.AlertServiceImpl">
        <property name="jmsOperations" ref="sendTmsTemplate"/>
    </bean>

傳送端介面與實現類

介面

public interface AlertService {
    void sendUserMsg(String dest , String msg);
}

實現類

package com.jx.spring.jms.server;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import org.springframework.jms.core.JmsOperations;
import org.springframework.jms.core.MessageCreator;

public class AlertServiceImpl implements AlertService{
    private JmsOperations jmsOperations;            //注入jms模板
    @Override
    public void sendUserMsg(final String dest , final String msg) {
        jmsOperations.send(             //傳送訊息
                dest,           //指定目的地
                new MessageCreator() {
                    @Override
                    public Message createMessage(Session session) throws JMSException {
                        return session.createTextMessage(msg);      //建立訊息
                    }
                }
            );
    }
    public JmsOperations getJmsOperations() {
        return jmsOperations;
    }
    public void setJmsOperations(JmsOperations jmsOperations) {
        this.jmsOperations = jmsOperations;
    }
}

傳送端傳送測試類

public static void main(String[] args) {

        ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("server.xml");
        AlertServiceImpl alert = (AlertServiceImpl) cxt.getBean("alertService");
        String dest = "myQueue";
        String msg = "hello";
        alert.sendUserMsg(dest , msg);

    }

接收端配置檔案

<!-- 配置連線工廠，指定訊息代理的URL -->

    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory" ref="pooledConnectionFactory"/>
    </bean> 

    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">  
        <property name="connectionFactory" ref="targetConnectionFactory"/>  
        <property name="maxConnections" value="10"/>  
    </bean>

    <bean id="targetConnectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://192.168.7.234:61616"/>
    </bean>

    <!-- 設定兩個目的地，一個是佇列形式，一個是主題模式（訂閱/釋出） -->
    <bean id="myQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 指定佇列名稱 -->
        <constructor-arg>
            <value>myQueue</value>
        </constructor-arg>
    </bean>

    <bean id="myTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <!-- 指定主題名稱 -->
        <constructor-arg>
            <value>myTopic</value>
        </constructor-arg>
    </bean>

    <!-- 訊息監聽器 -->  
    <bean id="myMessageListener" class="com.jx.spring.jms.client.MyMessageListener"/>      

    <!-- 訊息監聽容器 -->  
    <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
        <property name="connectionFactory" ref="connectionFactory" />  
        <property name="destination" ref="myQueue" />
        <property name="messageListener" ref="myMessageListener" />
    </bean>

接收端監聽類

package com.jx.spring.jms.client;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class MyMessageListener implements MessageListener{

    @Override
    public void onMessage(Message msg) {
        TextMessage text = (TextMessage) msg;
        System.out.println("client 1 收到一條訊息");
        try {
            System.out.println(text.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

}

接收端測試類

public static void main(String[] args) {

        ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("client.xml");
        System.out.println("接收者1啟動");
    }

其他說明

1 傳送端，接收端 連線工廠保持一致，目的地設定保持一致
2 若要傳送訂閱/釋出模式的，修改傳送者 pubSubDomain 改成 true

     <!-- 配置傳送者 -->
    <bean id="sendTmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
        <!-- 這個connectionFactory對應的是我們定義的Spring提供的那個ConnectionFactory物件 -->  
        <property name="connectionFactory" ref="connectionFactory"/>
        <!-- true/訂閱模式傳送，false/點對點的模式傳送 -->
        <property name="pubSubDomain" value="false"/>
    </bean>

3 MessageListener 是JMS標準的，純粹的接收訊息使用
SessionAwareMessageListener 是Spring為我們提供的，它不是標準的JMS MessageListener，可以在接收訊息的時候回覆一條訊息給傳送端