AMQ学习笔记 - 17. 事务的测试

概述

---

对事务机制进行测试。

测试实例

---

测试实例	结果预测
发送正常	3条消息入队
发送异常	0条消息入队
接收正常	3条消息出队
接收异常	0条消息出队

demo设计

---

设计图

测试分工

测试类	测试方法
TransactedProducer.java - 测试发送	sendNormal():void - 测试“发送正常”
	sendIntentional():void - 测试“发送异常”
TransactedConsumer.java - 测试接收	receiveNormal():void - 测试“接收正常”
	receiveIntentional():void - 测试“接收异常”

测试步骤和结果

---

1.测试发送

1.1.测试发送正常

测试步骤

1. 在ActiveMQ管理页面，删除example.queue
   - 如果存在就删除
2. 运行TransactedProducer#sendNormal()
   - 发送消息到example.queue
3. 查看ActiveMQ管理页面
   - example.queue中有3条消息入队

测试结果

符合预期。

1.2.测试发送异常

测试步骤

1. 在ActiveMQ管理页面，删除example.queue
   - 如果存在就删除
2. 运行TransactedProducer#sendIntentional()
   - 发送消息到example.queue
3. 查看控制台和ActiveMQ管理页面
   - 控制台有异常抛出
   - example.queue中入队消息0

测试结果

符合预期。

2.测试接收

2.1.测试接收正常

测试步骤

1. 在ActiveMQ管理页面，删除example.queue
   - 如果存在就删除
2. 运行TransactedProducer#sendNormal()
   - 发送消息到example.queue
3. 查看ActiveMQ管理页面
   - example.queue中有3条消息入队
4. 运行TransactedConsumer#receiveNormal()
   - 从example.queue中接收消息
5. 查看控制台和ActiveMQ管理页面
   - 控制台打印出3条信息
   - 管理页面看到example.queue中的3条消息出队

测试结果

符合预期。

2.2.测试接收异常

测试步骤

1. 在ActiveMQ管理页面，删除example.queue
   - 如果存在就删除
2. 运行TransactedProducer#sendNormal()
   - 发送消息到example.queue
3. 查看ActiveMQ管理页面
   - example.queue中有3条消息入队
4. 运行TransactedConsumer#receiveIntentional()
   - 从example.queue中接收消息
5. 查看控制台和ActiveMQ管理页面
   - 控制台打印出3条消息和异常信息
   - 管理页面看到example.queue中出队消息0条

测试结果

符合预期。

代码

---

文件目录结构

jms-producer
    |---- src/main/resources/
              |---- jndi.properties
    |---- src/main/java/
              |---- cn.sinobest.asj.producer.jms.transaction
                        |---- TransactedProducer.java # 测试发送
jms-consumer
    |---- src/main/resources/
              |---- jndi.properties # 和jms-producer中的jndi.properties一致
    |---- src/main/java/
              |---- cn.sinobest.asj.consumer.jms.transaction
                        |---- TransactedConsumer.java # 测试接收

文件内容

1.jndi.propertie

 java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory

 # use the following property to configure the default connector
 java.naming.provider.url=tcp://localhost:61616

 # register some queues in JNDI using the form
 # queue.[jndiName] = [physicalName]
 queue.exampleQueue=example.queue

 # register some topics in JNDI using the form
 # topic.[jndiName] = [physicalName]
 topic.exampleTopic=example.topic

2.TransactedProducer.java

 package cn.sinobest.asj.producer.jms.transaction;
 import javax.jms.Connection;
 import javax.jms.ConnectionFactory;
 import javax.jms.Destination;
 import javax.jms.JMSException;
 import javax.jms.MessageProducer;
 import javax.jms.Session;
 import javax.jms.TextMessage;
 import javax.naming.Context;
 import javax.naming.InitialContext;
 import javax.naming.NamingException;
 import org.junit.Test;
 /**
  * 事务的生产者.<br>
  * 测试发送正常和发送异常.
  * @author lijinlong
  *
  */
 public class TransactedProducer {
     /** JNDI name for ConnectionFactory */
     static final String CONNECTION_FACTORY_JNDI_NAME = "ConnectionFactory";
     /** JNDI name for Queue Destination (use for PTP Mode) */
     static final String QUEUE_JNDI_NAME = "exampleQueue";

     /** 是否故意异常 */
     boolean intentional = false;

     /**
      * 测试发送正常.
      */
     @Test
     public void sendNormal() {
         this.intentional = false;
         send(QUEUE_JNDI_NAME);
     }

     /**
      * 测试发送异常.
      */
     @Test
     public void sendIntentional() {
         this.intentional = true;
         send(QUEUE_JNDI_NAME);
     }

     /**
      * 是否故意抛出异常.<br>
      * 如果不抛出异常，会有3条消息入队；否则没有消息入队.
      * @return
      */
     private boolean isIntentional() {
         return intentional;
     }

     /**
      * 发送到指定的目的地.
      *
      * @param destJndiName
      *            目的地的JNDI name.
      */
     private void send(String destJndiName) {
         Context jndiContext = null;
         ConnectionFactory connectionFactory = null;
         Connection connection = null;
         Session session = null;
         Destination destination = null;
         MessageProducer producer = null;
         // create a JNDI API IntialContext object
         try {
             jndiContext = new InitialContext();
         } catch (NamingException e) {
             System.out.println("Could not create JNDI Context:"
                     + e.getMessage());
             System.exit(1);
         }
         // look up ConnectionFactory and Destination
         try {
             connectionFactory = (ConnectionFactory) jndiContext
                     .lookup(CONNECTION_FACTORY_JNDI_NAME);
             destination = (Destination) jndiContext.lookup(destJndiName);
         } catch (NamingException e) {
             System.out.println("JNDI look up failed:" + e.getMessage());
             System.exit(1);
         }
         // send Messages and finally release the resources.
         try {
             connection = connectionFactory.createConnection();
             session = connection.createSession(Boolean.TRUE,
                     Session.SESSION_TRANSACTED);
             producer = session.createProducer(destination);

             TextMessage message = session.createTextMessage();
             for (int i = 0; i < 3; i++) {
                 message.setText(String.format("This is the %dth message.",
                         i + 1));
                 producer.send(message);
             }

             if (isIntentional()) {
                 throw new JMSException("这是一个故意抛出的异常。");
             }

             session.commit(); // 在最后提交
         } catch (JMSException e) {
             try {
                 session.rollback();
             } catch (JMSException e1) {
                 e1.printStackTrace();
             }
             e.printStackTrace();
         } finally {
             try {
                 if (session != null)
                     session.close();
                 if (connection != null)
                     connection.close();
             } catch (JMSException e) {
                 e.printStackTrace();
             }
         }
     }
 }

TransactedProducer.java

3.TransactedConsumer.java

 package cn.sinobest.asj.consumer.jms.transaction;
 import javax.jms.Connection;
 import javax.jms.ConnectionFactory;
 import javax.jms.Destination;
 import javax.jms.JMSException;
 import javax.jms.Message;
 import javax.jms.MessageConsumer;
 import javax.jms.Session;
 import javax.jms.TextMessage;
 import javax.naming.Context;
 import javax.naming.InitialContext;
 import javax.naming.NamingException;
 import org.junit.Test;
 /**
  * 事务的接收者.<br>
  * 测试接收正常和接收异常.
  * @author lijinlong
  *
  */
 public class TransactedConsumer {
     /** JNDI name for ConnectionFactory */
     static final String CONNECTION_FACTORY_JNDI_NAME = "ConnectionFactory";
     /** JNDI name for Queue Destination (use for PTP Mode) */
     static final String QUEUE_JNDI_NAME = "exampleQueue";

     /** 是否故意异常 */
     boolean intentional = false;

     @Test
     public void receiveNormal() {
         intentional = false;
         receive(QUEUE_JNDI_NAME);
     }

     @Test
     public void receiveIntentional() {
         intentional = true;
         receive(QUEUE_JNDI_NAME);
     }

     /**
      * 是否故意抛出异常，以检查消息的出队情况.
      * @return
      */
     private boolean isIntentional() {
         return intentional;
     }

     /**
      * 接收消息.<br>
      *
      * @param destJndiName
      *            目的地的JNDI name.
      */
     private void receive(String destJndiName) {
         Context jndiContext = null;
         ConnectionFactory connectionFactory = null;
         Connection connection = null;
         Session session = null;
         Destination destination = null;
         MessageConsumer consumer = null;
         // create a JNDI API IntialContext object
         try {
             jndiContext = new InitialContext();
         } catch (NamingException e) {
             System.out.println("Could not create JNDI Context:"
                     + e.getMessage());
             System.exit(1);
         }
         // look up ConnectionFactory and Destination
         try {
             connectionFactory = (ConnectionFactory) jndiContext
                     .lookup(CONNECTION_FACTORY_JNDI_NAME);
             destination = (Destination) jndiContext.lookup(destJndiName);
         } catch (NamingException e) {
             System.out.println("JNDI look up failed:" + e.getMessage());
             System.exit(1);
         }
         // receive Messages and finally release the resources.
         try {
             connection = connectionFactory.createConnection();
             connection.start(); // connection should be called in
                                 // receiver-client
             session = connection.createSession(Boolean.TRUE,
                     Session.SESSION_TRANSACTED);
             consumer = session.createConsumer(destination);

             long timeout = 5 * 1000; // timeout:5 seconds
             for (Message message = consumer.receive(timeout); message != null; message = consumer.receive(timeout)) {
                 String text = ((TextMessage) message).getText();
                 System.out.println(text);
             }

             if (isIntentional()) {
                 throw new JMSException("这是一个故意抛出的异常。");
             }

             session.commit();
         } catch (JMSException e) {
             try {
                 session.rollback();
             } catch (JMSException e1) {
                 e1.printStackTrace();
             }
             e.printStackTrace();
         } finally {
             try {
                 if (session != null)
                     session.close();
                 if (connection != null)
                     connection.close();
             } catch (JMSException e) {
                 e.printStackTrace();
             }
         }
     }
 }

TransactedConsumer.java

来自为知笔记(Wiz)