java JMS消息队列

http://blog.csdn.net/shirdrn/article/details/6362792

http://haohaoxuexi.iteye.com/blog/1893038

http://afreon.blog.163.com/blog/static/223794094201431422654237/

http://www.cnblogs.com/huang0925/p/3558690.html

ActiveMQ第二弹:使用Spring JMS与ActiveMQ通讯

本文章的完整代码可从我的github中下载：https://github.com/huangbowen521/SpringJMSSample.git

上一篇文章中介绍了如何安装和运行ActiveMQ。这一章主要讲述如何使用Spring JMS向ActiveMQ的Message Queue中发消息和读消息。

首先需要在项目中引入依赖库。

  • spring-core: 用于启动Spring容器，加载bean。
  • spring-jms:使用Spring JMS提供的API。
  • activemq-all:使用ActiveMQ提供的API。

在本示例中我使用maven来导入相应的依赖库。

pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
      <dependency>
          <groupId>org.apache.activemq</groupId>
          <artifactId>activemq-all</artifactId>
          <version>5.9.0</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jms</artifactId>
          <version>4.0.2.RELEASE</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>4.0.2.RELEASE</version>
      </dependency>
  </dependencies>

接下来配置与ActiveMQ的连接，以及一个自定义的MessageSender。

springJMSConfiguration.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location">
            <value>application.properties</value>
        </property>
    </bean>

    <!-- Activemq connection factory -->
    <bean id="amqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <constructor-arg index="0" value="${jms.broker.url}"/>
    </bean>

    <!-- ConnectionFactory Definition -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="amqConnectionFactory"/>
    </bean>

    <!--  Default Destination Queue Definition-->
    <bean id="defaultDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg index="0" value="${jms.queue.name}"/>
    </bean>

    <!-- JmsTemplate Definition -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="defaultDestination" ref="defaultDestination"/>
    </bean>

    <!-- Message Sender Definition -->
    <bean id="messageSender" class="huangbowen.net.jms.MessageSender">
        <constructor-arg index="0" ref="jmsTemplate"/>
    </bean>
</beans>

在此配置文件中，我们配置了一个ActiveMQ的connection factory,使用的是ActiveMQ提供的ActiveMQConnectionFactory类。然后又配置了一个Spring JMS提供的CachingConnectionFactory。我们定义了一个ActiveMQQueue作为消息的接收Queue。并创建了一个JmsTemplate，使用了之前创建的ConnectionFactory和Message Queue作为参数。最后自定义了一个MessageSender，使用该JmsTemplate进行消息发送。

以下MessageSender的实现。

MessageSender.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package huangbowen.net.jms;

import org.springframework.jms.core.JmsTemplate;

public class MessageSender {

    private final JmsTemplate jmsTemplate;

    public MessageSender(final JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    public void send(final String text) {
        jmsTemplate.convertAndSend(text);
    }
}

这个MessageSender很简单，就是通过jmsTemplate发送一个字符串信息。

我们还需要配置一个Listener来监听和处理当前的Message Queue。

springJMSReceiver.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

    <!-- Message Receiver Definition -->
    <bean id="messageReceiver" class="huangbowen.net.jms.MessageReceiver">
    </bean>
    <bean class="org.springframework.jms.listener.SimpleMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="destinationName" value="${jms.queue.name}"/>
        <property name="messageListener" ref="messageReceiver"/>
    </bean>

</beans>

在上述xml文件中,我们自定义了一个MessageListener，并且使用Spring提供的SimpleMessageListenerContainer作为Container。

以下是MessageLinser的具体实现。

MessageReceiver.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package huangbowen.net.jms;

import javax.jms.*;

public class MessageReceiver implements MessageListener {

    public void onMessage(Message message) {
        if(message instanceof TextMessage) {
            TextMessage textMessage = (TextMessage) message;
            try {
                String text = textMessage.getText();
                System.out.println(String.format("Received: %s",text));
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

这个MessageListener也相当的简单，就是从Queue中读取出消息以后输出到当前控制台中。

另外有关ActiveMQ的url和所使用的Message Queue的配置在application.properties文件中。

application.properties

1
2

jms.broker.url=tcp://localhost:61616
jms.queue.name=bar

好了，配置大功告成。如何演示那？我创建了两个Main方法，一个用于发送消息到ActiveMQ的MessageQueue中，一个用于从MessageQueue中读取消息。

SenderApp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package huangbowen.net;

import huangbowen.net.jms.MessageSender;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.util.StringUtils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class SenderApp
{
    public static void main( String[] args ) throws IOException {
        MessageSender sender = getMessageSender();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String text = br.readLine();

        while (!StringUtils.isEmpty(text)) {
            System.out.println(String.format("send message: %s", text));
            sender.send(text);
            text = br.readLine();
        }
    }

    public static MessageSender getMessageSender() {
        ApplicationContext context = new ClassPathXmlApplicationContext("springJMSConfiguration.xml");
       return (MessageSender) context.getBean("messageSender");
    }
}

ReceiverApp.java

1
2
3
4
5
6
7
8
9
10

package huangbowen.net;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ReceiverApp {
    public static void main( String[] args )
    {
        new ClassPathXmlApplicationContext("springJMSConfiguration.xml", "springJMSReceiver.xml");
    }
}

OK，如果运行的话要先将ActiveMQ服务启动起来（更多启动方式参见我上篇文章）。

1

$:/usr/local/Cellar/activemq/5.8.0/libexec$ activemq start xbean:./conf/activemq-demo.xml

然后运行SenderApp中的Main方法，就可以在控制台中输入消息发送到ActiveMQ的Message Queue中了。运行ReceiverApp中的Main方法，则会从Queue中将消息读出来，打印到控制台。

这就是使用Spring JMS与ActiveMQ交互的一个简单例子了。完整代码可从https://github.com/huangbowen521/SpringJMSSample下载。

//------------------------------------------------------------------------------

基于Spring+JMS+ActiveMQ+Tomcat，我使用的版本情况如下所示：

  • Spring 2.5
  • ActiveMQ 5.4.0
  • Tomcat 6.0.30

下面通过学习与配置，实现消息服务的基本功能：发送与接收。Spring对JMS提供了很好的支持，可以通过JmsTemplate来方便地实现消息服务。这里，我们的消息服务不涉及事务管理。下面简单说明实现过程：

先看一下，我们最终的Spring配置文件applicationContext.xml的内容，如下所示：

[xhtml] view plaincopy

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:amq="http://activemq.apache.org/schema/core" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  5. http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">
  6. <bean id="listenerContainer"
  7. class="org.springframework.jms.listener.DefaultMessageListenerContainer">
  8. <property name="connectionFactory" ref="connectionFactory"></property>
  9. <property name="destination" ref="messageQueue"></property>
  10. <property name="messageListener" ref="receiveMessageListener"></property>
  11. </bean>
  12. <bean id="connectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
  13. <property name="jndiName" value="java:comp/env/myJMS/ConnectionFactory"></property>
  14. </bean>
  15. <bean id="messageQueue" class="org.springframework.jndi.JndiObjectFactoryBean">
  16. <property name="jndiName" value="java:comp/env/myJMS/MessageQueue"></property>
  17. </bean>
  18. <bean id="receiveMessageListener"
  19. class="org.shirdrn.spring.jms.integration.ReceiveMessageListener"></bean>
  20. <bean id="messageSender" class="org.shirdrn.spring.jms.integration.MessageSender">
  21. <property name="jmsTemplate" ref="jmsTemplate"></property>
  22. </bean>
  23. <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
  24. <property name="connectionFactory" ref="connectionFactory"></property>
  25. <property name="defaultDestination" ref="messageQueue"></property>
  26. </bean>
  27. <bean id="sendMessageController"
  28. class="org.shirdrn.spring.jms.integration.SendMessageController">
  29. <property name="messageSender" ref="messageSender" />
  30. <property name="successView" value="/success" />
  31. </bean>
  32. <bean id="urlMapping"
  33. class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  34. <property name="mappings">
  35. <props>
  36. <prop key="/sendMessage.do">sendMessageController</prop>
  37. </props>
  38. </property>
  39. </bean>
  40. <bean id="viewResolver"
  41. class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  42. <property name="requestContextAttribute" value="rc" />
  43. <property name="viewClass"
  44. value="org.springframework.web.servlet.view.JstlView" />
  45. <property name="prefix" value="/" />
  46. <property name="suffix" value=".jsp" />
  47. </bean>
  48. </beans>

我们使用Spring的org.springframework.jms.listener.DefaultMessageListenerContainer来收集消息，通过设置一个消息监听器，具体实现类为org.shirdrn.spring.jms.integration.ReceiveMessageListener，代码如下所示：

[java] view plaincopy

  1. package org.shirdrn.spring.jms.integration;
  2. import javax.jms.JMSException;
  3. import javax.jms.Message;
  4. import javax.jms.MessageListener;
  5. import javax.jms.TextMessage;
  6. import org.apache.log4j.Logger;
  7. public class ReceiveMessageListener implements MessageListener {
  8. private static final Logger LOG = Logger.getLogger(ReceiveMessageListener.class);
  9. public void onMessage(Message message) {
  10. if (message instanceof TextMessage) {
  11. TextMessage text = (TextMessage) message;
  12. try {
  13. LOG.info("Received message:" + text.getText());
  14. } catch (JMSException e) {
  15. e.printStackTrace();
  16. }
  17. }
  18. }
  19. }

上面，对发送的消息进行监听，并接收处理，我们只是简单地打印出一条日志内容。

对于listenerContainer，还需要注入连接工厂connectionFactory和消息目的destination这两个属性：connectionFactory我们使用ActiveMQ的org.apache.activemq.ActiveMQConnectionFactory，并通过JNDI服务，绑定到名字java:comp/env/myJMS/ConnectionFactory上；而destination属性通过使用ActiveMQ的org.apache.activemq.command.ActiveMQQueue消息队列，也是通过JNDI服务绑定到名字java:comp/env/myJMS/MessageQueue上。所以，在Tomcat的conf/context.xml中的<Context>元素里面加上如下配置：

[xhtml] view plaincopy

  1. <Resource name="myJMS/ConnectionFactory"
  2. auth="Container"
  3. type="org.apache.activemq.ActiveMQConnectionFactory"
  4. description="JMS Connection Factory"
  5. factory="org.apache.activemq.jndi.JNDIReferenceFactory"
  6. brokerURL="vm://shirdrnUrl"
  7. brokerName="MyActiveMQBroker"/>
  8. <Resource name="myJMS/MessageQueue"
  9. auth="Container"
  10. type="org.apache.activemq.command.ActiveMQQueue"
  11. description="My Message Queue"
  12. factory="org.apache.activemq.jndi.JNDIReferenceFactory"
  13. physicalName="MyMessageQueue"/>

我们通过使用JmsTemplate来实现消息的发送，所以实现的发送类要将JmsTemplate注入进去，实现代码如下所示：

[java] view plaincopy

  1. package org.shirdrn.spring.jms.integration;
  2. import javax.jms.JMSException;
  3. import javax.jms.Message;
  4. import javax.jms.Session;
  5. import javax.jms.TextMessage;
  6. import org.apache.log4j.Logger;
  7. import org.springframework.jms.core.JmsTemplate;
  8. import org.springframework.jms.core.MessageCreator;
  9. public class MessageSender {
  10. private static final Logger LOG = Logger.getLogger(MessageSender.class);
  11. private JmsTemplate jmsTemplate;
  12. public void setJmsTemplate(JmsTemplate jmsTemplate) {
  13. this.jmsTemplate = jmsTemplate;
  14. }
  15. public void sendMessage(final String message) {
  16. LOG.info("Send message: " + message);
  17. jmsTemplate.send(new MessageCreator() {
  18. public Message createMessage(Session session) throws JMSException {
  19. TextMessage textMessage = session.createTextMessage(message);
  20. return textMessage;
  21. }
  22. });
  23. }
  24. }

上面基于Spring的MessageCreator来创建消息，通过调用JmsTemplate的send方法发送出去。

对于Web，我们使用了Spring MVC，通过实现一个控制器org.shirdrn.spring.jms.integration.SendMessageController来控制页面消息的发送及其视图的派发。我们实现的SendMessageController类继承自MultiActionController，可以在一个控制器中实现多个Action，代码实现如下所示：

[java] view plaincopy

  1. package org.shirdrn.spring.jms.integration;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import javax.servlet.http.HttpServletRequest;
  5. import javax.servlet.http.HttpServletResponse;
  6. import org.springframework.web.servlet.ModelAndView;
  7. import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
  8. public class SendMessageController extends MultiActionController {
  9. private String successView;
  10. private MessageSender messageSender;
  11. public ModelAndView sendMessage(HttpServletRequest request,
  12. HttpServletResponse response) throws Exception {
  13. Map<String, Object> retMap = new HashMap<String, Object>();
  14. String message = request.getParameter("message");
  15. messageSender.sendMessage(message);
  16. return new ModelAndView(successView, retMap);
  17. }
  18. public String getSuccessView() {
  19. return successView;
  20. }
  21. public void setSuccessView(String successView) {
  22. this.successView = successView;
  23. }
  24. public MessageSender getMessageSender() {
  25. return messageSender;
  26. }
  27. public void setMessageSender(MessageSender messageSender) {
  28. this.messageSender = messageSender;
  29. }
  30. }

上面调用模型层（Model）的MessageSender来实现发送消息的处理逻辑，如果发送成功，视图派发到successView指定的页面。可以看到，最前面我们给出的Spring配置内容分为三组，最后一组是对控制器的配置：

viewResolver                     视图解析器配置，可以将控制器中指定前缀（/）解析为后缀是.jsp的页面，例如/success解析为/sucess.jsp

urlMapping                         请求URL与控制器的映射，例如对于满足/sendMessage.do模式的请求，都会被指派给sendMessageController去处理

sendMessageController      控制器实现类，里面的方法名称可以自定义，但要在org.springframework.web.servlet.handler.SimpleUrlHandlerMapping中的mappings属性中配置映射

然后，我们需要一个web部署描述文件，web.xml文件配置内容，如下所示：

[xhtml] view plaincopy

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
  5. http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  6. <context-param>
  7. <param-name>contextConfigLocation</param-name>
  8. <param-value>
  9. classpath:org/shirdrn/spring/jms/integration/applicationContext.xml
  10. </param-value>
  11. </context-param>
  12. <listener>
  13. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  14. </listener>
  15. <servlet>
  16. <servlet-name>controller</servlet-name>
  17. <servlet-class>
  18. org.springframework.web.servlet.DispatcherServlet
  19. </servlet-class>
  20. <init-param>
  21. <param-name>contextConfigLocation</param-name>
  22. <param-value>
  23. classpath:org/shirdrn/spring/jms/integration/applicationContext.xml
  24. </param-value>
  25. </init-param>
  26. <load-on-startup>1</load-on-startup>
  27. </servlet>
  28. <servlet-mapping>
  29. <servlet-name>controller</servlet-name>
  30. <url-pattern>*.do</url-pattern>
  31. </servlet-mapping>
  32. <welcome-file-list>
  33. <welcome-file>index.jsp</welcome-file>
  34. </welcome-file-list>
  35. </web-app>

另外，我们还要实现一个页面，提供输入发送消息的表单，提交后交给后台处理，成功发送后跳转到一个成功页面。表单输入页面为index.jsp，如下所示：

[java] view plaincopy

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%
  3. String path = request.getContextPath();
  4. String basePath = request.getScheme() + "://"
  5. + request.getServerName() + ":" + request.getServerPort()
  6. + path + "/";
  7. %>
  8. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  9. <html>
  10. <head>
  11. <base href="<%=basePath%>">
  12. <title>My JSP ‘index.jsp‘ starting page</title>
  13. <meta http-equiv="pragma" content="no-cache">
  14. <meta http-equiv="cache-control" content="no-cache">
  15. <meta http-equiv="expires" content="0">
  16. <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
  17. <meta http-equiv="description" content="This is my page">
  18. <!--
  19. <link rel="stylesheet" type="text/css" href="styles.css" mce_href="styles.css">
  20. -->
  21. </head>
  22. <body>
  23. <div align="center" style="width: 500px; height: 300px; border:2px; borderColor:black">
  24. <form action="sendMessage.do" method="post">
  25. <table align="center">
  26. <tr>
  27. <th colspan="2">
  28. 消息发送控制台
  29. </th>
  30. </tr>
  31. <tr>
  32. <td>
  33. 消息内容：
  34. </td>
  35. <td>
  36. <input type="text" name="message">
  37. </td>
  38. </tr>
  39. <tr>
  40. <td align="center" colspan="2">
  41. <input type="reset" value="清除">
  42. <input type="submit" value="发送">
  43. </td>
  44. </tr>
  45. </table>
  46. </form>
  47. </div>
  48. </body>
  49. </html>

成功页面为success.jsp，就是给一个成功的提示信息，如下所示：

[java] view plaincopy

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%
  3. String path = request.getContextPath();
  4. String basePath = request.getScheme() + "://"
  5. + request.getServerName() + ":" + request.getServerPort()
  6. + path + "/";
  7. %>
  8. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  9. <html>
  10. <head>
  11. <base href="<%=basePath%>">
  12. <title>My JSP ‘index.jsp‘ starting page</title>
  13. <meta http-equiv="pragma" content="no-cache">
  14. <meta http-equiv="cache-control" content="no-cache">
  15. <meta http-equiv="expires" content="0">
  16. <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
  17. <meta http-equiv="description" content="This is my page">
  18. <!--
  19. <link rel="stylesheet" type="text/css" href="styles.css" mce_href="styles.css">
  20. -->
  21. </head>
  22. <body>
  23. <div align="center" style="width: 500px; height: 300px; border:2px; borderColor:black">
  24. <form action="sendMessage.do" method="post">
  25. <table align="center">
  26. <tr>
  27. <th colspan="2">
  28. 消息发送报告
  29. </th>
  30. </tr>
  31. <tr>
  32. <td colspan="2">
  33. 状态：发送成功
  34. </td>
  35. </tr>
  36. <tr>
  37. <td align="center" colspan="2">
  38. <a href="index.jsp" mce_href="index.jsp">返回</a>
  39. </td>
  40. </tr>
  41. </table>
  42. </form>
  43. </div>
  44. </body>
  45. </html>

至此，我们可以将实现的简单web工程发布到Tomcat容器，然后启动Tomcat服务器，通过页面可以发送消息，并通过日志查看，实际消息发送和接收的情况。

时间： 2024-11-06 16:05:26

java JMS消息队列的相关文章

Flume 读取JMS 消息队列消息，并将消息写入HDFS

利用Apache Flume 读取JMS 消息队列消息.并将消息写入HDFS,flume agent配置例如以下: flume-agent.conf #name the  components on this agent agentHdfs.sources  = jms_source agentHdfs.sinks =  hdfs_sink agentHdfs.channels  = mem_channel #  Describe/configure the source agentHdfs.s

Java常用消息队列原理介绍及性能对比

消息队列使用场景 为什么会需要消息队列(MQ)? 解耦  在项目启动之初来预测将来项目会碰到什么需求,是极其困难的.消息系统在处理过程中间插入了一个隐含的.基于数据的接口层,两边的处理过程都要实现这一接口.这允许你独立的扩展或修改两边的处理过程,只要确保它们遵守同样的接口约束. 冗余  有些情况下,处理数据的过程会失败.除非数据被持久化,否则将造成丢失.消息队列把数据进行持久化直到它们已经被完全处理,通过这一方式规避了数据丢失风险.许多消息队列所采用的"插入-获取-删除"范式中,在把一

[Java] 分布式消息队列（MQ）

概述 场景 服务解耦 削峰填谷 异步化缓冲:最终一致性/柔性事务 MQ应用思考点 生产端可靠性投递 消费端幂等:消息只能消费一次 高可用.低延迟.可靠性 消息堆积能力 可扩展性 业界主流MQ ActiveMQ:适合传统需求,并发性差 RabbitMQ:扩展性差 RocketMQ:扩展性强 Kafka:扩展性强,并发性强,可靠性差 技术选型 性能.优缺点.业务场景 集群架构模式,分布式.可扩展.高可用.可维护性 综合成本,集群规模,人员成本 未来的方向.规划.思考 ActiveMQ 介绍 JMS(

JMS消息队列ActiveMQ(点对点模式)

生产者(producer)->消息队列(message queue) package com.java1234.activemq; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.MessageProducer; import javax.jms.Session

JMS消息队列ActiveMQ(发布／订阅模式)

消费者1(Consumer)--订阅(subcribe)-->主题(Topic) package com.java1234.activemq2; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.MessageConsumer; import javax.jms.

Java Mail + 消息队列 高效率发送邮件

本文主要是讲述JavaMail 和 消息队列的一些简单应用,这是第一次写博客,有很多不足的地方希望各位看客给出宝贵建议,另外本文写的不对的地方,请各位大神勿喷!!! 很多人都会在各个系统里面遇到发送邮件的功能,这次开博写文章也是在整理过程中发现,团队中有个新来的小童鞋对发送邮件这块不是很熟,所以自己准备写一个简单的样例. 这里加了一个消息队列主要是用于高并发的情况下,对邮件发送的控制,并可以对消息进行缓存,防止消息丢失. 话不多说直接上代码: 用maven对项目进行的管理,pom.xml <de

AMQP 与ActiveMQ，JMS消息队列之间的比较

http://blog.csdn.net/kimmking/article/details/8253549 http://www.csdn123.com/html/mycsdn20140110/8f/8f42bb0680685c547107a0079e557686.html http://blog.sina.com.cn/s/blog_999d1f4c01010dpx.html

Intellij IDEA 创建消息驱动Bean - 接收JMS消息

除了同步方式的调用之外,有时还需要异步调用,用来处理不需要即时处理的信息,例如短信.邮件等,这需要使用EJB中的独特组件——消息驱动Bean(Message-Driven Bean,MDB),它提供了Java消息服务JMS(Java Messaging Service)的处理能力,由消息驱动Bean来处理JMS消息.JMS的消息由客户端程序产生,并被发布到服务器的消息队列,消息驱动Bean随之检索消息并执行其内容.这种事件或者数据的通信就称为异步形式,客户端或者服务端Bean都无须依赖对方的直接

Netty构建分布式消息队列实现原理浅析

在本人的上一篇博客文章:Netty构建分布式消息队列(AvatarMQ)设计指南之架构篇 中,重点向大家介绍了AvatarMQ主要构成模块以及目前存在的优缺点.最后以一个生产者.消费者传递消息的例子,具体演示了AvatarMQ所具备的基本消息路由功能.而本文的写作目的,是想从开发.设计的角度,简单的对如何使用Netty,构建分布式消息队列背后的技术细节.原理,进行一下简单的分析和说明. 首先,在一个企业级的架构应用中,究竟何时需引入消息队列呢?本人认为,最经常的情况,无非这几种:做业务解耦.事件