`
langgufu
  • 浏览: 2307160 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Spring整合JMS(一)——基于ActiveMQ实现(转载)

阅读更多

本文转载自http://haohaoxuexi.iteye.com/blog/1893038

1.1     JMS简介

       JMS的全称是Java Message Service,即Java消息服务。它主要用于在生产者和消费者之间进行消息传递,生产者负责产生消息,而消费者负责接收消息。把它应用到实际的业务需求中的话我们可以在特定的时候利用生产者生成一消息,并进行发送,对应的消费者在接收到对应的消息后去完成对应的业务逻辑。对于消息的传递有两种类型,一种是点对点的,即一个生产者和一个消费者一一对应;另一种是发布/订阅模式,即一个生产者产生消息并进行发送后,可以由多个消费者进行接收。

1.2     Spring整合JMS

       JMS做了一个简要介绍之后,接下来就讲一下Spring整合JMS的具体过程。JMS只是一个标准,真正在使用它的时候我们需要有它的具体实现,这里我们就使用ApacheactiveMQ来作为它的实现。所使用的依赖利用Maven来进行管理,具体依赖如下:

 

Xml代码  收藏代码
  1. <dependencies>  
  2.         <dependency>  
  3.             <groupId>junit</groupId>  
  4.             <artifactId>junit</artifactId>  
  5.             <version>4.10</version>  
  6.             <scope>test</scope>  
  7.         </dependency>  
  8.         <dependency>  
  9.             <groupId>org.springframework</groupId>  
  10.             <artifactId>spring-context</artifactId>  
  11.             <version>${spring-version}</version>  
  12.         </dependency>  
  13.         <dependency>  
  14.             <groupId>org.springframework</groupId>  
  15.             <artifactId>spring-jms</artifactId>  
  16.             <version>${spring-version}</version>  
  17.         </dependency>  
  18.         <dependency>  
  19.             <groupId>org.springframework</groupId>  
  20.             <artifactId>spring-test</artifactId>  
  21.             <version>${spring-version}</version>  
  22.         </dependency>  
  23.         <dependency>  
  24.             <groupId>javax.annotation</groupId>  
  25.             <artifactId>jsr250-api</artifactId>  
  26.             <version>1.0</version>  
  27.         </dependency>  
  28.         <dependency>  
  29.             <groupId>org.apache.activemq</groupId>  
  30.             <artifactId>activemq-core</artifactId>  
  31.             <version>5.7.0</version>  
  32.         </dependency>  
  33. </dependencies>  

 

1.2.1  activeMQ准备

       既然是使用的apacheactiveMQ作为JMS的实现,那么首先我们应该到apache官网上下载activeMQhttp://activemq.apache.org/download.html),进行解压后运行其bin目录下面的activemq.bat文件启动activeMQ

1.2.2配置ConnectionFactory

       ConnectionFactory是用于产生到JMS服务器的链接的,Spring为我们提供了多个ConnectionFactory,有SingleConnectionFactoryCachingConnectionFactorySingleConnectionFactory对于建立JMS服务器链接的请求会一直返回同一个链接,并且会忽略Connectionclose方法调用。CachingConnectionFactory继承了SingleConnectionFactory,所以它拥有SingleConnectionFactory的所有功能,同时它还新增了缓存功能,它可以缓存SessionMessageProducerMessageConsumer。这里我们使用SingleConnectionFactory来作为示例。

Xml代码  收藏代码
  1. <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory"/>  

 

       这样就定义好产生JMS服务器链接的ConnectionFactory了吗?答案是非也。Spring提供的ConnectionFactory只是Spring用于管理ConnectionFactory的,真正产生到JMS服务器链接的ConnectionFactory还得是由JMS服务厂商提供,并且需要把它注入到Spring提供的ConnectionFactory中。我们这里使用的是ActiveMQ实现的JMS,所以在我们这里真正的可以产生Connection的就应该是由ActiveMQ提供的ConnectionFactory。所以定义一个ConnectionFactory的完整代码应该如下所示:

Xml代码  收藏代码
  1. <!-- 真正可以产生Connection的ConnectionFactory,由对应的 JMS服务厂商提供-->  
  2. <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
  3.     <property name="brokerURL" value="tcp://localhost:61616"/>  
  4. </bean>  
  5.   
  6. <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
  7. <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
  8.     <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
  9.     <property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
  10. </bean>  

  

       ActiveMQ为我们提供了一个PooledConnectionFactory,通过往里面注入一个ActiveMQConnectionFactory可以用来将ConnectionSessionMessageProducer池化,这样可以大大的减少我们的资源消耗。当使用PooledConnectionFactory时,我们在定义一个ConnectionFactory时应该是如下定义:

 

Xml代码  收藏代码
  1. <!-- 真正可以产生Connection的ConnectionFactory,由对应的 JMS服务厂商提供-->  
  2. <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
  3.     <property name="brokerURL" value="tcp://localhost:61616"/>  
  4. </bean>  
  5.   
  6. <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">  
  7.     <property name="connectionFactory" ref="targetConnectionFactory"/>  
  8.     <property name="maxConnections" value="10"/>  
  9. </bean>  
  10.   
  11. <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
  12.     <property name="targetConnectionFactory" ref="pooledConnectionFactory"/>  
  13. </bean>  

1.2.3配置生产者

配置好ConnectionFactory之后我们就需要配置生产者。生产者负责产生消息并发送到JMS服务器,这通常对应的是我们的一个业务逻辑服务实现类。但是我们的服务实现类是怎么进行消息的发送的呢?这通常是利用Spring为我们提供的JmsTemplate类来实现的,所以配置生产者其实最核心的就是配置进行消息发送的JmsTemplate。对于消息发送者而言,它在发送消息的时候要知道自己该往哪里发,为此,我们在定义JmsTemplate的时候需要往里面注入一个Spring提供的ConnectionFactory对象。

Xml代码  收藏代码
  1. <!-- Spring提供的JMS工具类,它可以进行消息发送、接收等 -->  
  2. <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
  3.     <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
  4.     <property name="connectionFactory" ref="connectionFactory"/>  
  5. </bean>  

 

       在真正利用JmsTemplate进行消息发送的时候,我们需要知道消息发送的目的地,即destination。在Jms中有一个用来表示目的地的Destination接口,它里面没有任何方法定义,只是用来做一个标识而已。当我们在使用JmsTemplate进行消息发送时没有指定destination的时候将使用默认的Destination。默认Destination可以通过在定义jmsTemplate bean对象时通过属性defaultDestinationdefaultDestinationName来进行注入,defaultDestinationName对应的就是一个普通字符串。在ActiveMQ中实现了两种类型的Destination,一个是点对点的ActiveMQQueue,另一个就是支持订阅/发布模式的ActiveMQTopic。在定义这两种类型的Destination时我们都可以通过一个name属性来进行构造,如:

 

Xml代码  收藏代码
  1. <!--这个是队列目的地,点对点的-->  
  2. <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">  
  3.     <constructor-arg>  
  4.         <value>queue</value>  
  5.     </constructor-arg>  
  6. </bean>  
  7. <!--这个是主题目的地,一对多的-->  
  8. <bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">  
  9.     <constructor-arg value="topic"/>  
  10. </bean>  

       假设我们定义了一个ProducerService,里面有一个向Destination发送纯文本消息的方法sendMessage,那么我们的代码就大概是这个样子:

 

Java代码  收藏代码
  1. package com.tiantian.springintejms.service.impl;  
  2.    
  3. import javax.annotation.Resource;  
  4. import javax.jms.Destination;  
  5. import javax.jms.JMSException;  
  6. import javax.jms.Message;  
  7. import javax.jms.Session;  
  8.    
  9. import org.springframework.jms.core.JmsTemplate;  
  10. import org.springframework.jms.core.MessageCreator;  
  11. import org.springframework.stereotype.Component;  
  12.    
  13. import com.tiantian.springintejms.service.ProducerService;  
  14.    
  15. @Component  
  16. public class ProducerServiceImpl implements ProducerService {  
  17.    
  18.     private JmsTemplate jmsTemplate;  
  19.       
  20.     public void sendMessage(Destination destination, final String message) {  
  21.         System.out.println("---------------生产者发送消息-----------------");  
  22.         System.out.println("---------------生产者发了一个消息:" + message);  
  23.         jmsTemplate.send(destination, new MessageCreator() {  
  24.             public Message createMessage(Session session) throws JMSException {  
  25.                 return session.createTextMessage(message);  
  26.             }  
  27.         });  
  28.     }   
  29.   
  30.     public JmsTemplate getJmsTemplate() {  
  31.         returnjmsTemplate;  
  32.     }   
  33.   
  34.     @Resource  
  35.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  36.         this.jmsTemplate = jmsTemplate;  
  37.     }  
  38.    
  39. }  

       我们可以看到在sendMessage方法体里面我们是通过jmsTemplate来发送消息到对应的Destination的。到此,我们生成一个简单的文本消息并把它发送到指定目的地Destination的生产者就配置好了。

1.2.4配置消费者

生产者往指定目的地Destination发送消息后,接下来就是消费者对指定目的地的消息进行消费了。那么消费者是如何知道有生产者发送消息到指定目的地Destination了呢?这是通过Spring为我们封装的消息监听容器MessageListenerContainer实现的,它负责接收信息,并把接收到的信息分发给真正的MessageListener进行处理。每个消费者对应每个目的地都需要有对应的MessageListenerContainer。对于消息监听容器而言,除了要知道监听哪个目的地之外,还需要知道到哪里去监听,也就是说它还需要知道去监听哪个JMS服务器,这是通过在配置MessageConnectionFactory的时候往里面注入一个ConnectionFactory来实现的。所以我们在配置一个MessageListenerContainer的时候有三个属性必须指定,一个是表示从哪里监听的ConnectionFactory;一个是表示监听什么的Destination;一个是接收到消息以后进行消息处理的MessageListenerSpring一共为我们提供了两种类型的MessageListenerContainerSimpleMessageListenerContainerDefaultMessageListenerContainer

SimpleMessageListenerContainer会在一开始的时候就创建一个会话session和消费者Consumer,并且会使用标准的JMS MessageConsumer.setMessageListener()方法注册监听器让JMS提供者调用监听器的回调函数。它不会动态的适应运行时需要和参与外部的事务管理。兼容性方面,它非常接近于独立的JMS规范,但一般不兼容Java EEJMS限制。

大多数情况下我们还是使用的DefaultMessageListenerContainer,跟SimpleMessageListenerContainer相比,DefaultMessageListenerContainer会动态的适应运行时需要,并且能够参与外部的事务管理。它很好的平衡了对JMS提供者要求低、先进功能如事务参与和兼容Java EE环境。

定义处理消息的MessageListener

       要定义处理消息的MessageListener我们只需要实现JMS规范中的MessageListener接口就可以了。MessageListener接口中只有一个方法onMessage方法,当接收到消息的时候会自动调用该方法。

 

Java代码  收藏代码
  1. package com.tiantian.springintejms.listener;  
  2.    
  3. import javax.jms.JMSException;  
  4. import javax.jms.Message;  
  5. import javax.jms.MessageListener;  
  6. import javax.jms.TextMessage;  
  7.    
  8. public class ConsumerMessageListener implements MessageListener {  
  9.    
  10.     public void onMessage(Message message) {  
  11.         //这里我们知道生产者发送的就是一个纯文本消息,所以这里可以直接进行强制转换  
  12.         TextMessage textMsg = (TextMessage) message;  
  13.         System.out.println("接收到一个纯文本消息。");  
  14.         try {  
  15.             System.out.println("消息内容是:" + textMsg.getText());  
  16.         } catch (JMSException e) {  
  17.             e.printStackTrace();  
  18.         }  
  19.     }  
  20.    
  21. }  

 

       有了MessageListener之后我们就可以在Spring的配置文件中配置一个消息监听容器了。

Xml代码  收藏代码
  1. <!--这个是队列目的地-->  
  2. <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">  
  3.     <constructor-arg>  
  4.         <value>queue</value>  
  5.     </constructor-arg>  
  6. </bean>  
  7. <!-- 消息监听器 -->  
  8. <bean id="consumerMessageListener" class="com.tiantian.springintejms.listener.ConsumerMessageListener"/>      
  9.   
  10. <!-- 消息监听容器 -->  
  11. <bean id="jmsContainer"        class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
  12.     <property name="connectionFactory" ref="connectionFactory" />  
  13.     <property name="destination" ref="queueDestination" />  
  14.     <property name="messageListener" ref="consumerMessageListener" />  
  15. </bean>  

  

       我们可以看到我们定义了一个名叫queueActiveMQQueue目的地,我们的监听器就是监听了发送到这个目的地的消息。

       至此我们的生成者和消费者都配置完成了,这也就意味着我们的整合已经完成了。这个时候完整的Spring的配置文件应该是这样的:

Xml代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:jms="http://www.springframework.org/schema/jms"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7.      http://www.springframework.org/schema/context  
  8.      http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  9.     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  10.     http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">  
  11.    
  12.     <context:component-scan base-package="com.tiantian" />  
  13.    
  14.     <!-- Spring提供的JMS工具类,它可以进行消息发送、接收等 -->  
  15.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
  16.         <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
  17.         <property name="connectionFactory" ref="connectionFactory"/>  
  18.     </bean>  
  19.       
  20.     <!-- 真正可以产生Connection的ConnectionFactory,由对应的 JMS服务厂商提供-->  
  21.     <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
  22.         <property name="brokerURL" value="tcp://localhost:61616"/>  
  23.     </bean>  
  24.       
  25.     <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
  26.     <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">  
  27.         <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
  28.         <property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
  29.     </bean>  
  30.       
  31.     <!--这个是队列目的地-->  
  32.     <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">  
  33.         <constructor-arg>  
  34.             <value>queue</value>  
  35.         </constructor-arg>  
  36.     </bean>  
  37.     <!-- 消息监听器 -->  
  38.     <bean id="consumerMessageListener" class="com.tiantian.springintejms.listener.ConsumerMessageListener"/>  
  39.     <!-- 消息监听容器 -->  
  40.     <bean id="jmsContainer"  
  41.         class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
  42.         <property name="connectionFactory" ref="connectionFactory" />  
  43.         <property name="destination" ref="queueDestination" />  
  44.         <property name="messageListener" ref="consumerMessageListener" />  
  45.     </bean>  
  46. </beans>  

 

 

       接着我们来测试一下,看看我们的整合是否真的成功了,测试代码如下:

 

Java代码  收藏代码
  1. package com.tiantian.springintejms.test;  
  2.    
  3. import javax.jms.Destination;  
  4.    
  5. import org.junit.Test;  
  6. import org.junit.runner.RunWith;  
  7. import org.springframework.beans.factory.annotation.Autowired;  
  8. import org.springframework.beans.factory.annotation.Qualifier;  
  9. import org.springframework.test.context.ContextConfiguration;  
  10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  11. import com.tiantian.springintejms.service.ProducerService;  
  12.    
  13. @RunWith(SpringJUnit4ClassRunner.class)  
  14. @ContextConfiguration("/applicationContext.xml")  
  15. public class ProducerConsumerTest {  
  16.    
  17.     @Autowired  
  18.     private ProducerService producerService;  
  19.     @Autowired  
  20.     @Qualifier("queueDestination")  
  21.     private Destination destination;  
  22.       
  23.     @Test  
  24.     public void testSend() {  
  25.         for (int i=0; i<2; i++) {  
  26.             producerService.sendMessage(destination, "你好,生产者!这是消息:" + (i+1));  
  27.         }  
  28.     }  
  29.       
  30. }  

 

       在上面的测试代码中我们利用生产者发送了两个消息,正常来说,消费者应该可以接收到这两个消息。运行测试代码后控制台输出如下:

 

 

       看,控制台已经进行了正确的输出,这说明我们的整合确实是已经成功了。

 

 附:

分享到:
评论

相关推荐

    Spring整合JMS——实现收发消息

    总结来说,Spring整合JMS和ActiveMQ的过程包括:配置ConnectionFactory,定义Destination,创建MessageListener容器,以及使用JmsTemplate发送消息。通过这种方式,你可以构建一个健壮的、异步的消息传递系统,提高...

    Spring整合JMS(四)——事务管理

    总的来说,Spring整合JMS的事务管理是一个复杂但关键的过程,它涉及到消息的可靠传递和系统的一致性。理解并正确配置事务管理能够帮助我们构建出健壮的分布式系统。通过Spring的声明式事务管理,我们可以优雅地处理...

    Spring 实现远程访问详解——jms和activemq

    3. Spring 整合JMS和ActiveMq流程 1) 下载和部署ActiveMq服务器 2) Spring jms和activemq相关依赖引入 3) Spring整合activemq配置 4) 定义消息发布者(生产者) 5) 定义消息订阅者(消费者) 6) Spring mvc配置 7) 实例...

    ActiveMQ整合spring的Demo

    ActiveMQ整合Spring的Demo是一个典型的Java企业级应用示例,它展示了如何在Spring框架中集成Apache ActiveMQ,以便实现消息队列的功能。ActiveMQ是Apache软件基金会的一个开源项目,它是一个功能丰富的Java消息服务...

    ActiveMQ 入门实战(3)--SpringBoot 整合 ActiveMQ(csdn)————程序.pdf

    总结,本篇文章介绍了如何在 SpringBoot 项目中集成 ActiveMQ,通过引入依赖、配置连接参数、创建消息生产者和消费者,实现了基于 JMS 的消息传递功能。同时,我们还探讨了 ActiveMQ 和 Spring JMS 的核心概念以及...

    ActiveMQ与Spring联合使用Demo

    在将ActiveMQ与Spring整合的过程中,我们需要完成以下步骤: 1. **配置ActiveMQ**:首先,我们需要在本地或服务器上安装并运行ActiveMQ。这可以通过下载ActiveMQ的二进制包,然后启动`bin/activemq`脚本来完成。...

    springboot整合activemq案例

    在本文中,我们将深入探讨如何将Spring Boot与ActiveMQ整合,构建一个实用的消息传递系统。首先,我们需要了解Spring Boot和ActiveMQ的基本概念。 Spring Boot是一个快速开发框架,它简化了基于Spring的应用程序...

    activemq-spring-5.5.0.jar.zip

    《ActiveMQ与Spring整合——深度解析5.5.0版本》 在Java消息服务(Java Message Service,简称JMS)领域,Apache ActiveMQ是广泛使用的开源消息代理和集成框架。它支持多种协议,如OpenWire、AMQP、STOMP、MQTT等,...

    activemq-spring-1.4.jar.zip

    《ActiveMQ与Spring整合——深度解析activemq-spring-1.4.jar》 在Java世界里,消息中间件扮演着至关重要的角色,它能够帮助应用程序解耦,提高系统的可扩展性和容错性。ActiveMQ作为Apache软件基金会的一款开源...

    activemq-spring-1.3.jar.zip

    《ActiveMQ与Spring整合——深度解析activemq-spring-1.3.jar》 在Java消息服务(JMS)领域,Apache ActiveMQ是一款广泛应用的消息中间件,它支持多种协议,如OpenWire、AMQP、STOMP等,为分布式系统提供可靠的消息...

    activemq-spring-2.0.jar.zip

    《ActiveMQ与Spring整合——深度解析activemq-spring-2.0.jar.zip》 在IT行业中,消息中间件扮演着至关重要的角色,它能够帮助应用程序解耦,提高系统的可扩展性和可靠性。Apache ActiveMQ是Java领域最流行的消息...

    activemq-spring-1.2_001.jar.zip

    《ActiveMQ与Spring整合——深度解析activemq-spring-1.2_001.jar.zip》 在Java世界中,消息中间件ActiveMQ扮演着至关重要的角色,它提供了高效、可靠的异步通信机制,而Spring框架则以其强大的依赖注入和面向切面...

    activemq 配置说明与activemq入门讲解

    Apache ActiveMQ是业界广泛使用的开源消息中间件,它遵循JMS(Java Message Service)标准,提供了高可用性、可伸缩性和可靠的消息传递服务。在本文中,我们将深入探讨ActiveMQ的配置及其入门知识。 一、ActiveMQ...

    spring+MQ消息队列

    ActiveMQ是Apache软件基金会的一个开源项目,它是一个完全支持JMS 1.1和NMS API的、高性能且可靠的MQ实现。JMS(Java Message Service)是Java平台中定义的一种标准接口,用于在分布式环境中发送和接收消息。 1. **...

    apache-activemq-5.3.0-bin.zip

    Apache ActiveMQ是世界上最流行的开源消息代理和队列服务器,它基于Java Message Service(JMS)规范,提供可靠的消息传递服务。这个"apache-activemq-5.3.0-bin.zip"压缩包包含了Apache ActiveMQ的5.3.0版本的源...

    Camel-CSV2SQL-Example:示例 Camel 单路由使用 Spring Java 配置,通过 JMS (ActiveMQ) 队列获取 CSV 文件,通过 Velocity 模板处理它,并将 SQL INSERT 语句输出到另一个 JMS 队列

    这个流程涉及到从JMS(Java Message Service,如ActiveMQ)队列接收CSV文件,使用Velocity模板引擎对数据进行转换,然后将转换后的结果——即SQL INSERT语句——发送到另一个JMS队列。以下是详细的步骤和知识点: 1...

    Java消息服务(第2版)

    由于更新了JMS 1.1,第二版还说明了厂商无关的规范将有助于你写基于messaging的应用程序,无论是使用IBM的MQ、Progress软件的SonicMQ、ActiveMQ的,还是其他专有的消息服务。 有了《Java消息服务》,你将可以: ·...

    消息事件说明文档

    ### 消息事件说明文档——ActiveMQ使用及注意事项 #### 一、ActiveMQ概述 **1.1 ActiveMQ概念** ActiveMQ是一款非常流行的开源消息中间件,它实现了JMS(Java Message Service)标准,能够为应用程序提供可靠的...

    ESB产品说明

    Apache ServiceMix是另一个基于JBI标准的ESB实现,它不仅支持常见的协议如JMS、HTTP、FTP、FILE,还实现了EIP模式,使其成为一个全面的集成平台。作为Apache基金会的顶级项目,ServiceMix于2005年被Apache接纳,并在...

    MuleESB3.0中文教程

    - **核心特性**:基于EIP(Enterprise Integration Patterns)原则构建,支持多种传输协议(如file, FTP, UDP, SMTP, HTTP, SOAP, JMS等),并且整合了多个流行的开源项目(如Spring, ActiveMQ, CXF, Axis, Drools等...

Global site tag (gtag.js) - Google Analytics