精通Spring集成：企业级集成模式基础

需积分: 3 77 浏览量更新于2024-07-17 收藏 2.9MB PDF 举报

"Just Spring Integration" 是一本由 Madhusudhan Konda 编著的英文原版高清图书，专注于讲解企业集成模式的基础知识。本书详细阐述了 Spring Integration 框架，包括声明式编程模型、核心消息传递、适配器以及对 JMS、RMI 和 Web 服务的支持。作为 "Just Spring" 的理想补充，它旨在以易于理解的方式教授 Spring 技术。在 Spring Integration 中，作者Madhusudhan Konda深入探讨了以下关键知识点： 1. **企业集成模式（Enterprise Integration Patterns）**：这是集成系统的核心理论框架，书中介绍了如何利用模式来解决企业级应用之间的通信问题，如异步处理、消息转换和路由策略。 2. **声明式编程模型**：Spring Integration 提供了一种声明式的编程方式，使得开发者可以通过配置文件而不是编码实现系统间的集成，简化了复杂集成的实现。 3. **核心消息传递**：Spring Integration 基于发布-订阅和点对点的消息传递模型，提供了消息通道（channels）、消息源（message sources）和消息处理器（message handlers）等组件，用于构建可扩展和灵活的集成解决方案。 4. **适配器（Adapters）**：适配器是 Spring Integration 与外部系统交互的关键部分，如文件系统适配器、数据库适配器、HTTP 适配器等，它们将 Spring Integration 的消息传递机制与不同系统的接口连接起来。 5. **JMS 支持**：Java 消息服务（JMS）是一个标准，用于在分布式环境中进行消息传递。Spring Integration 提供了对 JMS 的全面支持，包括生产者、消费者、消息转换等功能，便于与 JMS 兼容的消息中间件（如 ActiveMQ、Apache Kafka 等）集成。 6. **RMI 支持**：远程方法调用（RMI）是 Java 平台上的远程对象交互技术。Spring Integration 提供了 RMI 适配器，允许在分布式系统中无缝地调用远程对象的方法。 7. **Web 服务支持**：通过 SOAP 或 RESTful 风格的 Web 服务，Spring Integration 提供了创建和消费 Web 服务的能力，这在跨组织、跨平台的集成中非常常见。 8. **其他特性**：书中还可能涵盖了工作流管理、事务处理、错误处理和监控等方面，这些都是构建健壮集成解决方案时不可或缺的部分。 "Just Spring Integration" 是一本全面介绍 Spring Integration 的指南，它不仅适合初学者理解集成的基本概念，也适用于有经验的开发者深入学习和优化他们的集成方案。通过阅读此书，读者可以学习到如何有效地使用 Spring Integration 来构建稳定、高效的企业级集成解决方案。

Integrating disparate systems is not an uncommon task. Before the advent of integration

frameworks, there were common strategies in the integration space. The most popular

strategies are:

• Shared File Systems: Two or more applications share a common file system; one

may write to it while the other may poll the file system to read it. The sender and

receiver are decoupled in this case. This solution certainly works, but has draw-

backs like performance, reliability, and dependency on the File system.

• Single Database: In this strategy, applications share the data from a single data-

base. One application writes data to the table while the other simply reads from

the table. The drawback is that this setup forces applications to use a unified

schema throughout the organization. Shared databases also pose a few other issues,

such as network lag and lock contention.

• Messaging: This strategy mainly encourages and supports sender-receiver

decoupling. A sender application sends a piece of data enclosed in a message to a

messaging middleman and forgets about it. A consumer consumes the message

whenever it can and begins its own workflow. One of the advantages of using

Messaging as the medium is that the sender and receiver are decoupled completely.

Also, the messages can be enriched, transformed, routed, and filtered before hitting

the end channels.

We will examine the Messaging strategy and how Spring Integration gives us the tools

to develop a full-fledged application.

Messaging Patterns

We all know that in our day-to-day life, there are some common problems that may

have common solutions. In the messaging domain, too, you can observe such recurring

problems and encounter some solutions to them. These common solutions are recor-

ded as patterns. During the last couple of decades, formal patterns emerged for some

of the recurring problems. Instead of reinventing the wheel, one could create the sol-

utions using the approach laid out by these patterns. For example, to decouple the

sender and receiver, one can introduce a Message pattern—the sender sends a message,

while the receiver receives this message. Each party is unaware of the other.

Any messaging system has a few building blocks to work with, such as Messages,

Channels, Transformers, etc. These are identified as patterns and discussed later in the

chapter.

One pattern that might require a mention is the pipes and filters pattern.

Let’s look at a very simple example to demonstrate this pattern—a Unix pipeline ( | )

command. Most of us should be familiar with this command.

2 | Chapter 1: Integration Fundamentals

The pipeline command, denoted by |, is used to combine several Unix commands to

achieve a complex task. Although it looks simple, this example shows the powerful

concept of the pipes and filters architecture.

Our requirement is to find the word count of Just Spring in the just-spring-

titles.txt file. Run the command as shown below to achieve this:

mkonda$ cat just-spring-titles.txt | grep "Just Spring" | wc -l

Going into detail, the above command consists of three endpoints and two channels.

The cat, grep, and wc are the endpoints while the pipe (|) acts as a channel.

The cat command displays the contents of the file. But the display, instead of being

sent to the screen, is sent to the grep command using the pipe. The grep command then

picks up the contents and searches for the Just Spring string. The result is then passed

on to another command, wc, in this case. This simply displays the word count on the

screen.

Note that these commands do not know anything about each other. These are small,

narrowly focused tools that take in messages and publish them. They don’t depend on

each other’s API and can be developed independently.

If you are familiar with JMS or distributed technologies, you may have heard of Enter-

prise Messaging. Your application talking to another application over the network can

be considered an Enterprise application. You may have to use an application server to

host these applications if you want to expose services so other applications can call the

service according to their needs.

However, we can also introduce messaging to a standalone program that may run in a

single process (single JVM). Spring Integration is one such framework for inter- and

intra-application messaging.

While knowing these patterns will help you understand Spring Integration technology,

it is not a requirement. The Spring Integration framework is developed to implement

the patterns discussed in Enterprise Integration Patterns by Gregor Hohpe and Bobby

Woolf. I would advise you to read this book to understand the EAI subject in depth.

Traditional Programming Model

Let’s consider an application that loads Trades from an external system (File, in this

example). The requirements of processing these Trades are as follows:

• Trades should be segregated based on Trade types (NEW, CANCEL, AMEND, etc).

• Trades are then processed accordingly and persisted.

• An auditor tool should be notified once the Trades are persisted.

These are typical application requirements. Usually, one can code them in a single

component, as shown in the example below:

Integration Strategies | 3

剩余97页未读，继续阅读

Java刺客

粉丝: 13
资源: 11

精通Spring集成：企业级集成模式基础

Just spring integration

spring Integration 介绍

JustSpringIntegrationFreePdfBook.pdf 英文原版

写一个springboot集成mqtt的配置

如何使用 spring reactor

spring webflux 的案例

java 中spring BodyInserter转json

spring gateway 拦截所有请求统一返回response

springboot just的作用

最新资源