ESB学习笔记（Spring Integration实战）

最新推荐文章于 2024-09-26 19:19:06 发布
最新推荐文章于 2024-09-26 19:19:06 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： camel 文章标签： Spring Bean SVN XML Ant
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyhighwl/article/details/83364108
版权

ESB学习笔记（Spring Integration实战）

介绍
Spring Integration是Spring公司的一套ESB框架。
前面ESB介绍中我也做了一定了解。我们来看一下它主要做什么的。
Spring Integration is motivated by the following goals:
  • Provide a simple model for implementing complex enterprise integration solutions.(暂时相信它吧，谁让它搞个Spring框架，的确给人方便一把。)
  • Facilitate asynchronous, message-driven behavior within a Spring-based application.(这个不谈，Spring框架就是它玩的。再说这一点与它竞争只有Mule啦。)
  • Promote intuitive, incremental adoption for existing Spring users. (也暂时相信它，别人都只说给用户提升。)

Spring Integration is guided by the following principles:
  • Components should be loosely coupled for modularity and testability.（松耦合，好像很早很早就听说过。像做梦一样）
  • The framework should enforce separation of concerns between business logic and integration logic.（分开程度要取决业务吧。）
  • Extension points should be abstract in nature but within well-defined boundaries to promote reuse and portability.（美妙现实世界产品）

源码下载打开它的网页， http://www.springsource.org/spring-integration
主页上也没有东东，但有个下源代码的地方，svn开工啦。
Java代码 复制代码
  1. svn co https://src.springframework.org/svn/spring-integration/trunk  springintegration   
svn co https://src.springframework.org/svn/spring-integration/trunk  springintegration

下载完后，进入build-spring-integration目录执行ant.完成后，导入到Eclipse中。
导入项目会有很多，先添加时会有报错。这里需要添加一个变量。
IVY_CACHE＝<checkout-dir>/ivy-cache/repository

这里要注意的事，也是我遇到问题。执行ant时，他会去下载lvy，如果你本身在%ANT_HOME%\lib里有lvy.jar包，由于我暂时找不到如何处理，我就直接将Ant中的jar删除掉后就没有问题。
另外在ant过程中，测试步骤可能会在file模块中出现问题，可以将相关test类中代码注释掉。

HelloWorld源码分析在samples项目中，打开helloworld包里面有三个文件。
Java代码 复制代码
  1. package org.springframework.integration.samples.helloworld;   
  2.   
  3. /**  
  4.  * @author Mark Fisher  
  5.  */  
  6. public class HelloService {   
  7.   
  8.     public String sayHello(String name) {   
  9.         return "Hello " + name;   
  10.     }   
  11.   
  12. }  
package org.springframework.integration.samples.helloworld;

/**
 * @author Mark Fisher
 */
public class HelloService {

	public String sayHello(String name) {
		return "Hello " + name;
	}

}

helloworldDemo.xml
Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans:beans xmlns="http://www.springframework.org/schema/integration"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:beans="http://www.springframework.org/schema/beans"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
  6.             http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  7.             http://www.springframework.org/schema/integration   
  8.             http://www.springframework.org/schema/integration/spring-integration-1.0.xsd">  
  9.   
  10.     <channel id="inputChannel"/>  
  11.   
  12.     <channel id="outputChannel">  
  13.         <queue capacity="10"/>  
  14.     </channel>  
  15.   
  16.     <service-activator input-channel="inputChannel"  
  17.                        output-channel="outputChannel"  
  18.                        ref="helloService"  
  19.                        method="sayHello"/>  
  20.   
  21.     <beans:bean id="helloService" class="org.springframework.integration.samples.helloworld.HelloService"/>  
  22. </beans:beans>  
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/integration"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
			http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springframework.org/schema/integration
			http://www.springframework.org/schema/integration/spring-integration-1.0.xsd">

	<channel id="inputChannel"/>

	<channel id="outputChannel">
		<queue capacity="10"/>
	</channel>

	<service-activator input-channel="inputChannel"
	                   output-channel="outputChannel"
	                   ref="helloService"
	                   method="sayHello"/>

	<beans:bean id="helloService" class="org.springframework.integration.samples.helloworld.HelloService"/>
</beans:beans>

HelloWorldDemo.java
Java代码 复制代码
  1. package org.springframework.integration.samples.helloworld;   
  2.   
  3. import org.springframework.context.support.AbstractApplicationContext;   
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  5. import org.springframework.integration.channel.BeanFactoryChannelResolver;   
  6. import org.springframework.integration.channel.ChannelResolver;   
  7. import org.springframework.integration.channel.PollableChannel;   
  8. import org.springframework.integration.core.MessageChannel;   
  9. import org.springframework.integration.message.StringMessage;   
  10.   
  11. /**  
  12.  * Demonstrates a basic message endpoint.   
  13.  *   
  14.  * @author Mark Fisher  
  15.  */  
  16. public class HelloWorldDemo {   
  17.   
  18.     public static void main(String[] args) {   
  19.         AbstractApplicationContext context = new ClassPathXmlApplicationContext("helloWorldDemo.xml", HelloWorldDemo.class);   
  20.         ChannelResolver channelResolver = new BeanFactoryChannelResolver(context);   
  21.         MessageChannel inputChannel = channelResolver.resolveChannelName("inputChannel");   
  22.         PollableChannel outputChannel = (PollableChannel) channelResolver.resolveChannelName("outputChannel");   
  23.         inputChannel.send(new StringMessage("World"));   
  24.         System.out.println(outputChannel.receive(0).getPayload());   
  25.         context.stop();   
  26.     }   
  27.   
  28. }  
package org.springframework.integration.samples.helloworld;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.integration.channel.BeanFactoryChannelResolver;
import org.springframework.integration.channel.ChannelResolver;
import org.springframework.integration.channel.PollableChannel;
import org.springframework.integration.core.MessageChannel;
import org.springframework.integration.message.StringMessage;

/**
 * Demonstrates a basic message endpoint. 
 * 
 * @author Mark Fisher
 */
public class HelloWorldDemo {

	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("helloWorldDemo.xml", HelloWorldDemo.class);
		ChannelResolver channelResolver = new BeanFactoryChannelResolver(context);
		MessageChannel inputChannel = channelResolver.resolveChannelName("inputChannel");
		PollableChannel outputChannel = (PollableChannel) channelResolver.resolveChannelName("outputChannel");
		inputChannel.send(new StringMessage("World"));
		System.out.println(outputChannel.receive(0).getPayload());
		context.stop();
	}

}


Cafe源码分析 Cafe示例描述的是星巴克的订单处理故事。
其示例描述在： http://www.enterpriseintegrationpatterns.com/ramblings/18_starbucks.html
这里简单描述一下，以免大家看英文太累
文章讲在星巴克喝咖啡时，收银员可能只有一个，而冲咖啡员工会有多个，如何让收银员产生订单异步发送给冲咖啡员工。并且冲咖啡员工可能是竞争上岗的，就当他们是计件工吧。
这里要考虑问题：
1，冲咖啡员工使用不同设备，不同咖啡冲调时间可能不同。　
2，冲咖啡员工可能会将相同类型的咖啡同时一起冲调。
星巴克如何处理这个问题？
就当他解决了这个问题，它是如何把每个咖啡又送回给每个客户呢？当然，星巴克采用“标识关系模式”，将每个咖啡杯上标上名称，并通过叫喊方式。
但并不是每天都是美好的，总有出错的时候。例如，收银员无法支付？冲调一杯你不喜欢的咖啡，你要换一杯？冲咖啡的设备坏了，星巴克要退你钱...这些异常情况如何处理。
因此就会有以下三种方式异常处理：
1,关闭交易，什么都不做。
2,重做，重新发起行为。
3,修正行为,相当于退钱这种行为。
因此，这里这篇文章后面讨论一下两阶段提交为什么不适合星巴克，如果你让收银员、冲咖啡员工，买单的人需要在一个“事务”中，交易所有完成后，再进行下一个业务。估计星巴克会马上倒闭啦。因此星巴克采用“Conversation pattern”模式。

好啦，业务了解清楚，我们再来看一下完整XML文件。在这里我没有采用示例详细的xml方式，而没有采用annotation方式。

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans:beans xmlns="http://www.springframework.org/schema/integration"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:beans="http://www.springframework.org/schema/beans"  
  5.     xmlns:stream="http://www.springframework.org/schema/integration/stream"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
  7.             http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  8.             http://www.springframework.org/schema/integration   
  9.             http://www.springframework.org/schema/integration/spring-integration-1.0.xsd   
  10.             http://www.springframework.org/schema/integration/stream   
  11.             http://www.springframework.org/schema/integration/stream/spring-integration-stream-1.0.xsd">  
  12.   
  13.     <gateway id="cafe" service-interface="org.springframework.integration.samples.cafe.Cafe"/>  
  14.   
  15.     <channel id="orders"/>  
  16.     <splitter input-channel="orders" ref="orderSplitter" method="split" output-channel="drinks"/>  
  17.   
  18.     <channel id="drinks"/>  
  19.     <router input-channel="drinks" ref="drinkRouter" method="resolveOrderItemChannel"/>  
  20.   
  21.     <channel id="coldDrinks">  
  22.         <queue capacity="10"/>  
  23.     </channel>  
  24.     <service-activator input-channel="coldDrinks" ref="barista"  
  25.                        method="prepareColdDrink" output-channel="preparedDrinks"/>  
  26.   
  27.     <channel id="hotDrinks">  
  28.         <queue capacity="10"/>  
  29.     </channel>  
  30.     <service-activator input-channel="hotDrinks" ref="barista"  
  31.                        method="prepareHotDrink" output-channel="preparedDrinks"/>  
  32.   
  33.     <channel id="preparedDrinks"/>  
  34.     <aggregator input-channel="preparedDrinks" ref="waiter"  
  35.                 method="prepareDelivery" output-channel="deliveries"/>  
  36.   
  37.     <stream:stdout-channel-adapter id="deliveries"/>  
  38.   
  39.     <beans:bean id="orderSplitter"  
  40.                 class="org.springframework.integration.samples.cafe.xml.OrderSplitter"/>  
  41.   
  42.     <beans:bean id="drinkRouter"  
  43.                 class="org.springframework.integration.samples.cafe.xml.DrinkRouter"/>  
  44.   
  45.     <beans:bean id="barista" class="org.springframework.integration.samples.cafe.xml.Barista"/>  
  46.   
  47.     <beans:bean id="waiter" class="org.springframework.integration.samples.cafe.xml.Waiter"/>  
  48.   
  49.     <poller id="poller" default="true">  
  50.         <interval-trigger interval="1000"/>  
  51.     </poller>  
  52.   
  53. </beans:beans>  
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/integration"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:stream="http://www.springframework.org/schema/integration/stream"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/integration
            http://www.springframework.org/schema/integration/spring-integration-1.0.xsd
            http://www.springframework.org/schema/integration/stream
            http://www.springframework.org/schema/integration/stream/spring-integration-stream-1.0.xsd">

    <gateway id="cafe" service-interface="org.springframework.integration.samples.cafe.Cafe"/>

    <channel id="orders"/>
    <splitter input-channel="orders" ref="orderSplitter" method="split" output-channel="drinks"/>

    <channel id="drinks"/>
    <router input-channel="drinks" ref="drinkRouter" method="resolveOrderItemChannel"/>

    <channel id="coldDrinks">
        <queue capacity="10"/>
    </channel>
    <service-activator input-channel="coldDrinks" ref="barista"
                       method="prepareColdDrink" output-channel="preparedDrinks"/>

    <channel id="hotDrinks">
        <queue capacity="10"/>
    </channel>
    <service-activator input-channel="hotDrinks" ref="barista"
                       method="prepareHotDrink" output-channel="preparedDrinks"/>

    <channel id="preparedDrinks"/>
    <aggregator input-channel="preparedDrinks" ref="waiter"
                method="prepareDelivery" output-channel="deliveries"/>

    <stream:stdout-channel-adapter id="deliveries"/>

    <beans:bean id="orderSplitter"
                class="org.springframework.integration.samples.cafe.xml.OrderSplitter"/>

    <beans:bean id="drinkRouter"
                class="org.springframework.integration.samples.cafe.xml.DrinkRouter"/>

    <beans:bean id="barista" class="org.springframework.integration.samples.cafe.xml.Barista"/>

    <beans:bean id="waiter" class="org.springframework.integration.samples.cafe.xml.Waiter"/>

    <poller id="poller" default="true">
        <interval-trigger interval="1000"/>
    </poller>

</beans:beans>


以下是参考文档中的示例描述图：



CafeDemo代码创建了订单。这家咖啡店有两种饮料，一种是热的，一种是冷的，消息将这订单包装到一个"orders"的channel（频道）。一个endpoint侦听到订单频道并根据订单情况进行分开处理。

完成分开处理后，程序交给DrinksRouter经过drink频道。而DrinkRouter一个职责就是将订单内容中的热咖啡和冷咖啡交给不同的channel处理。

Xml代码 复制代码
  1. <gateway id="cafe" service-interface="org.springframework.integration.samples.cafe.Cafe"/>  
	<gateway id="cafe" service-interface="org.springframework.integration.samples.cafe.Cafe"/>

这里Gateway主要是根据接口生成代理类。

Java代码 复制代码
  1. Cafe cafe = (Cafe) context.getBean("cafe");   
  2.                 DrinkOrder order = new DrinkOrder();   
  3.                 Drink hotDoubleLatte = new Drink(DrinkType.LATTE, 2, false);   
  4.                 Drink icedTripleMocha = new Drink(DrinkType.MOCHA, 3, true);   
  5.                 order.addDrink(hotDoubleLatte);   
  6.                 order.addDrink(icedTripleMocha);   
  7.                 for (int i = 0; i < 100; i++) {   
  8.                         cafe.placeOrder(order);   
  9.                 }  
Cafe cafe = (Cafe) context.getBean("cafe");
                DrinkOrder order = new DrinkOrder();
                Drink hotDoubleLatte = new Drink(DrinkType.LATTE, 2, false);
                Drink icedTripleMocha = new Drink(DrinkType.MOCHA, 3, true);
                order.addDrink(hotDoubleLatte);
                order.addDrink(icedTripleMocha);
                for (int i = 0; i < 100; i++) {
                        cafe.placeOrder(order);
                }



Java代码 复制代码
  1. @MessageEndpoint(input="orders", output="drinks")   
  2. public class OrderSplitter {   
  3.   
  4.         @Splitter  
  5.         public List<Drink> split(Message<DrinkOrder> orderMessage) {   
  6.                 return orderMessage.getPayload().getDrinks();   
  7.         }   
  8.   
  9. }  
@MessageEndpoint(input="orders", output="drinks")
public class OrderSplitter {

        @Splitter
        public List<Drink> split(Message<DrinkOrder> orderMessage) {
                return orderMessage.getPayload().getDrinks();
        }

}


Java代码 复制代码
  1. @MessageEndpoint(input="drinks")   
  2. public class DrinkRouter {   
  3.   
  4.         @Router  
  5.         public String resolveDrinkChannel(Drink drink) {   
  6.                 return (drink.isIced()) ? "coldDrinks" : "hotDrinks";   
  7.         }   
  8.   
  9. }  
@MessageEndpoint(input="drinks")
public class DrinkRouter {

        @Router
        public String resolveDrinkChannel(Drink drink) {
                return (drink.isIced()) ? "coldDrinks" : "hotDrinks";
        }

}


Xml代码 复制代码
  1. <handler-endpoint handler="coldBarista" input-channel="coldDrinks"  
  2.         method="prepareColdDrink">  
  3. </handler-endpoint>  
  4.   
  5. <handler-endpoint handler="hotBarista" input-channel="hotDrinks"  
  6.         method="prepareHotDrink">  
  7. </handler-endpoint>  
<handler-endpoint handler="coldBarista" input-channel="coldDrinks"
        method="prepareColdDrink">
</handler-endpoint>

<handler-endpoint handler="hotBarista" input-channel="hotDrinks"
        method="prepareHotDrink">
</handler-endpoint>


Java代码 复制代码
  1. public void prepareColdDrink(Message<Drink> drinkMessage) {   
  2.                 Drink drink = drinkMessage.getPayload();   
  3.                 //no changes to the rest of the code   
  4.         }  
flyhighwl
关注
专栏目录
spring integration 项目实战一、之项目介绍和环境搭建
joinandjoin的专栏
01-15 2873
        网上见到很少的spring integration 的实际使用教程，碰巧最近项目中遇到一个需求，非常适合使用spring integration 进行开发，于是参考spring integration 的Refrence，自己摸索了下算初步完成，现在已经在运行中。在此发布出来，一是为了记录自己的工作成果；二是为了抛块砖头引下玉，希望大家可以多指出改进的地方。一起学习和完善spr...
Spring全家桶的深入学习(十）:Spring Integration集成模式实现企业ESB
我的博客
07-15 8173
文章目录背景Spring IntegrationSpring Integration的几个重要概念Spring Integration集成模式实战入口网关消息过滤器处理单元（发送消息）集成组件修改用户服务业务逻辑功能测试小结 背景 《Spring全家桶的深入学习(一）:Spring起步》 《Spring全家桶的深入学习(二）:基于SpringMVC开发web应用》 《Spring全家桶的深入学习(三）:实现数据持久化》 《Spring全家桶的深入学习(四）:使用Spring Data实现数据持久化》 《Sp
Spring Integration 项目实战
0808xyj的专栏
07-05 3681
简介：   Spring Integration能在基于Spring的应用中进行简单的消息通信，并通过简单的适配器与外部系统集成。 需求场景：    1、两个异构系统，系统A 是 Java 软件项目,数据库是Oracle，系统B 是 .net 软件项目，数据库是SQL Server，系统A 有一部分数据 需 实时同步给系统B    2、监控系统  用途：   1、利用Spring
SOA（企业服务总线ESB架构实现）
最新发布
m0_71745484的博客
09-26 1000
*企业服务总线（Enterprise Service Bus，ESB）**是SOA架构中的核心组成部分，主要用于促进企业内部异构系统和应用程序之间的集成与通信。ESB提供了一个统一的服务集成平台，通过使用消息路由、协议转换、服务编排等功能，实现了不同服务之间的无缝通信。我们将详细学习ESB架构的实现，包括其核心功能、架构组件、实现步骤和最佳实践。示例：一个企业有多个业务系统，比如CRM系统、ERP系统和供应链管理系统，它们使用不同的协议和数据格式。
Spring Integration 实例讲解
热门推荐
FOREVER_DO
07-14 1万+
Spring Integration简介组件介绍实例演示买饮料jms做一个简单的示例。实例三集成JDBC 简介 最近学习到的工具，资料很少，但还是要记录下自己目前的理解，官方的说发就不说了网上都一样，这里我说点自己的理解，其实spring integeration就类似一个水电系统，总闸，各层楼的控制，分流，聚合，过滤，沉淀，消毒，排污这里的每一个环节都类似一个系统服务，可能是jms,可能是red...
Spring-Integration-in-Action：本书随附的源代码
03-01
Spring整合行动 该项目包含“ Spring Integration in Action”（Manning，2012年）一书中的代码示例。 要构建和运行测试，请转到“ siia-examples”目录并执行：mvn test 要将工件安装到本地Maven存储库中，请执行：mvn install 为了探索代码，我们建议将项目（位于子目录中）导入到诸如Eclipse或IntelliJ Idea之类的IDE中。 有关这本书的更多信息，请访问 。 模组 “ siia-examples”的模块如下： 模块 描述 章节 批 使用Spring Batch和Spring Integration的批处理应用程序 16 商业 业务逻辑调用（变压器，服务激活器） 5 并发 并发配置（轮询器，任务执行器） 15 机票预订 路由，XML处理和测试的更复杂示例 6、8、18 基本面 解耦代码
Spring学习笔记+学习源码.zip
05-12
9. **Spring Integration**：提供了异步处理、消息驱动和企业服务总线（ESB）等集成解决方案。 10. **Spring Batch**：用于处理批量操作，如数据导入导出，适合大规模数据处理。 在学习笔记中，你可能会找到以下...
Spring Integration学习笔记一
joinandjoin的专栏
06-23 1998
一、概述        Spring Integration是Spring框架创建的又一个API，面向企业应用集成（EAI）。它是可以理解为一种ESB框架，可以和EJB、RMI、JMS这些标准技术协同使用，使得各个应用之间可以协同通讯。另一个优点是它可以和应用一起部署而不需要单独建立ESB服务器。 二、Spring Integration 组件        1.1、 Messages （消
EIP, ESB,API网关学习笔记
evasnowind的专栏
01-14 1838
EIP、ESB、API网关学习笔记 目标 说明EIP、ESB、API网关： 基本概念 相互之间的区别与联系 使用场景 常见框架 主要是知识整理，做个笔记，摘抄内容会给出出处。 预备知识 SOA 在聊EIP ESB这些知识前，首先要了解什么是SOA。 SOA是面向服务架构，是一种建设企业IT生态系统的架构指导思想。SOA的关注点是服务。 服务最基本的业务功能单元，由平台中立性的接口契约来定义。 通过将业务系统服务化，可以将不同模块解耦，各种异构系统间可以轻松实现服务调用、消息交换和资源共享。 借用一
玩转springcloud（一）：什么是Springcloud ，有什么优缺点？ 学习顺序是什么？
Y1Zzz的博客
08-23 1235
Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智能路由，微代理，控制总线）。分布式系统的协调导致了样板模式, 使用Spring Cloud开发人员可以快速地支持实现这些模式的服务和应用程序。他们将在任何分布式环境中运行良好，包括开发人员自己的笔记本电脑，裸机数据中心，以及Cloud Foundry等托管平台。其中有着很多的特性：Spring Cloud专注于提供良好的开箱即用经验的典型用例和可扩展性机制覆盖。分布式/版本化配置。
达内,tarena,spring笔记,springPPT课件,达内spring笔记
05-13
9. **Spring Integration**：提供异步处理、消息驱动和企业服务总线（ESB）功能，方便系统间的集成。 10. **Spring Batch**：专门用于批量处理任务的框架，支持复杂的批处理需求，如事务管理、错误处理和分页。 ...
ESB应用Spring_AOP
04-19
ESB应用Spring_AOP
ESB应用Spring_Hello_World
04-19
ESB应用Spring_Hello_World
Spring Integration + Spring WS 整合
03-14
SpringIntegration整合SpringWS,其实Spring Integration用的WebService服务就是Spring WS的。这是两个组件的小demo，对新手入门比较有用。
Spring Integration API（Spring Integration 开发文档）.CHM
08-31
Spring Integration。 官网 Spring Integration API。 Spring Integration 开发文档。
Spring Integration源码
08-11
Spring-Integration-in-Action 源码
Spring Integration概述
liubowin的专栏
07-04 7532
Spring Integration概述 1.1  背景               Spring Integration是Spring项目中秉承其相同目标和原则的新成员。它扩展了Spring的编程模型到消息领域，在Spring已经存在的企业集成支持的基础上，提供了更高级别的抽象。它将控制反转添加到关注点，支持消息驱动架构，例如当特定业务逻辑应该执行时，响应也应该被发送。它支持路由和消息转换
Spring Integration
来啊 快活啊
04-03 786
Spring Integration 是 Enterprise Integration Patterns中描述设计模式的实现；Apache Camel也是 Enterprise Integration Patterns的实现； Overview Refrence Enterprise Integration Pattern - 组成简介 按照Enterprise Integration...
JBoss ESB学习笔记12——第十一个ESB应用Spring Hello World
FAFA2008的专栏
04-01 271
续上篇介绍了第十个ESB应用，本文介绍第十一个ESB应用——Spring Hello World。   说明：本文及后续文章虽非百分百的原创，但毕竟包含本人的努力和付出，所以希望大家转载时务请注明出处：http://yarafa.iteye.com，谢谢合作。     1 概述本实例主要演示了基于spring的action调用，这里需要引用spring相关的jar包，这些jar包都可以在...
JBoss ESB学习笔记：CustomAction实战解析
这个应用对于学习者理解ESB的工作原理，特别是如何利用action类和消息队列进行服务间通信具有很高的价值。同时，这也提醒我们，配置是ESB应用中的重要环节，正确配置服务和消息队列是确保系统顺畅运行的基础。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值