Spring Integration Framework简介

最新推荐文章于 2024-08-15 03:04:47 发布

dnc8371

最新推荐文章于 2024-08-15 03:04:47 发布

阅读量2k

点赞数

我们非常了解Spring框架和JMS 。在本文中，我们将介绍称为Spring Integration的企业集成框架 。 Spring Integration是一个开源企业集成框架，可增强Spring单独完成的功能。 Spring Integration构建在Spring的IoC之上，它抽象了消息源和目标，集成了消息，路由并对其进行操作，同时集成了应用程序环境的各种组件。

Spring Integration用于通信的Message对象由有效负载和标头数据组成。 有效负载包含实际数据，而标头包含其他元数据，例如id ， timestamp等。下图说明了Spring Integration通信中涉及的不同组件

因此，让我们创建一个示例Spring Integration应用程序：

使用自定义Java接口作为入站网关

创建一个新的Maven项目。

将依赖项添加到pom.xml文件中：

<properties>
       <spring.version>4.0.0.RELEASE</spring.version>
       <jms.version>1.1-rev-1</jms.version>
       <activemq.version>3.1</activemq.version>
       <spring.integration.version>2.2.5.RELEASE</spring.integration.version>
       <junit.version>4.11</junit.version>
       <spring.test.version>3.2.3.RELEASE</spring.test.version>
</properties>

<!-- Spring Integration -->
<dependency>
       <groupId>org.springframework.integration</groupId>
       <artifactId>spring-integration-core</artifactId>
       <version>${spring.integration.version}</version>
</dependency>
<dependency>
       <groupId>org.springframework.integration</groupId>
       <artifactId>spring-integration-jms</artifactId>
       <version>${spring.integration.version}</version>
</dependency>

<!-- Include Spring test -->
<dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-test</artifactId>
       <version>${spring.test.version}</version>
       <scope>test</scope>
</dependency>

<!-- Include JUnit -->
<dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>${junit.version}</version>
       <scope>test</scope>
</dependency>

创建学生实体类Student.java ，如：

package com.jcombat.entity;
 
public class Student {
	String name;
 
	public Student(String name) {
		this.name = name;
	}
 
	public String getName() {
		return name;
	}
}

现在，让我们在上下文文件中配置spring集成组件（将其命名为Test-context.xml ）：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jms="http://www.springframework.org/schema/jms" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:int-jme="http://www.springframework.org/schema/integration"
	xmlns:int="http://www.springframework.org/schema/integration"
	xmlns:int-jms="http://www.springframework.org/schema/integration/jms"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   
	    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
	    http://www.springframework.org/schema/context  
	    http://www.springframework.org/schema/context/spring-context-3.0.xsd  
	    http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
	    http://www.springframework.org/schema/integration/jms http://www.springframework.org/schema/integration/jms/spring-integration-jms.xsd
	    http://www.springframework.org/schema/jms  
	    http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">
 
	<!-- Enable annotations -->
	<context:annotation-config/>
	
	<!-- Component scan to find all Spring components -->
 	<context:component-scan base-package="org.jcombat.integration"/>
 
	<bean id="simpleMessageReceiver" class="com.jcombat.integration.DemoMessageReceiver" />
 
	<!-- Define a request channel to communicate -->
	<int:channel id="request" />
 
	<int:outbound-channel-adapter channel="request" ref="simpleMessageReceiver" method="processMessage" />
	
	<int:gateway id="demoGateway" service-interface="com.jcombat.integration.DemoGatewayInterface"
		default-request-channel="request"></int:gateway>
	
</beans>

消息通道是封装实际数据并使消息生产者与使用者分离的东西。

网关基本上是消息传递系统的入口/出口点。因此，如果您有一个消息传递服务器，例如ActiveMQ或TIBCO，则DefaultMessageListener充当入站网关，是我们消息传递系统的入口点。

当消息到达配置的通道时， Service Activator用于调用本地服务，其方式是该服务不知道正在从消息传递系统中调用该服务。

适配器从外部消息传递系统（JMS，SFTP等）接收消息，并将其“适配”到消息传递系统（作为Spring Integration Message <T> ）。入站JMS适配器接收传入的外部消息，并将其“调整”为Spring Integration Message <T>类型。反之亦然：它需要一个Spring Integration Message <T>并将其“调整”为外部系统所需的格式。

因此，一旦消息通过入站适配器进入，它就会通过Channels从一个组件流向另一个组件。最终，将消息写到某个地方可能是适当的。我们可以使用出站适配器编写消息。

现在，让我们创建在上下文中指定的网关接口，如下所示：

package com.jcombat.integration;
 
import com.jcombat.entity.Student;
 
public interface DemoGatewayInterface {
	public void process(Student student);
}

创建一个接收器类，该类将在被适配器路由后最终从通道接收传入消息。

package com.jcombat.integration;
 
import org.springframework.integration.Message;
 
import com.jcombat.entity.Student;
 
public class DemoMessageReceiver {
	public void processMessage(Message<Student> message) {
		Student student = message.getPayload();
		System.out.println("Message Received - Student Name - " + student.getName());
	}
}

就是这个。最后，我们需要一个客户端来调用网关接口方法。让我们使用Spring Test Framework来做到这一点：

package com.jcombat.integration;
 
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import com.jcombat.entity.Student;
import com.jcombat.integration.DemoGatewayInterface;
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class Test {
 
	@Autowired
	private DemoGatewayInterface request;
 
	@org.junit.Test
	public void testIntegration() {
		Student emp = new Student("Abhishek");
		request.process(emp);
	}
}

将您的应用程序添加到服务器并启动服务器。
导航到我们在上文第7点中创建的Test.java文件，并将其作为JUnit测试运行。以下是我们在IDE控制台中看到的日志：

使用Spring DefaultMessageListener作为入站网关

创建一个新的Maven项目。
确保ActiveMQ服务器已启动并正在运行。
首先是将条目输入pom.xml文件。因此，这与前面的情况相同。

让我们编写上下文文件（ jmsContext.xml ），并将Spring Integration组件配置为：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jms="http://www.springframework.org/schema/jms" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:int-jme="http://www.springframework.org/schema/integration"
	xmlns:int="http://www.springframework.org/schema/integration"
	xmlns:int-jms="http://www.springframework.org/schema/integration/jms"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   
	    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
	    http://www.springframework.org/schema/context  
	    http://www.springframework.org/schema/context/spring-context-3.0.xsd  
	    http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
	    http://www.springframework.org/schema/integration/jms http://www.springframework.org/schema/integration/jms/spring-integration-jms.xsd
	    http://www.springframework.org/schema/jms  
	    http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">
 
	<bean id="connectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory">
		<property name="brokerURL" value="tcp://localhost:61616" />
	</bean>
 
	<bean id="messageListenerContainer"
		class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destinationName" value="testQueue" />
		<property name="maxConcurrentConsumers" value="1" />
		<property name="concurrentConsumers" value="1" />
		<property name="receiveTimeout" value="5000" />
		<property name="recoveryInterval" value="60000" />
		<property name="autoStartup" value="true" />
	</bean>
 
	<!-- Define a channel to communicate out to a JMS Destination -->
	<int:channel id="inbound" />
	<int:channel id="outbound" />
 
	<bean id="simpleMessageListener" class="com.jcombat.listener.SimpleMessageListener" />
	
	<int-jms:message-driven-channel-adapter
		id="jmsIn" container="messageListenerContainer" channel="inbound"
		acknowledge="auto" />
 
	<int:service-activator input-channel="inbound"
		output-channel="outbound" ref="simpleMessageListener" method="onMessage" />
 
	<int-jms:outbound-channel-adapter id="jmsOut"
		channel="outbound" connection-factory="connectionFactory"
		destination-name="sampleQueue" />
 
</beans>

让我们在服务器启动时加载上下文。为此，请在web.xml文件中输入适当的内容，如下所示：

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
                        http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
                        version="3.0">
                        
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/jmsContext.xml</param-value>
	</context-param>
 
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
</web-app>

创建侦听器类，该类将最终接收消息，如下所示：

package com.jcombat.listener;
 
public class SimpleMessageListener {
 
	public String onMessage(String message) {
		System.out.println(message);
		return message;
	}
}

是时候运行我们的应用程序了。因此，这应该作为：
1. 发送自定义消息到testQueue ：
2. 侦听器被调用，它的onMessage方法被执行，将进入的消息记录为IDE控制台：
3. 消息通过出站通道并通过出站适配器传递到目标sampleQueue ，如下所示：
下载源代码

您可以在此处下载源代码。