Just Spring Integration：初学者指南到企业级消息架构

需积分: 9 28 浏览量更新于2024-07-24 收藏 4.29MB PDF 举报

《Just Spring Integration》是由Madhusudhan Konda撰写的一本专业书籍，它在2012年4月出版，专门针对Spring框架下的集成开发进行深入讲解。这本书旨在帮助读者理解和掌握企业级项目中所面临的复杂消息传递挑战，特别是当市场上充斥着各种各样的消息产品，如JMS（Java Message Service）和JCA（Java Connector Architecture）等，这些技术规范虽然强大但初学者往往难以入门。在早期2000年代，作者作为一个刚接触企业项目的开发者，经历了这一时期企业消息架构的混乱与复杂性。作者分享了自己在那个时代面临的困难，即如何在一个标准众多、功能各异的环境中选择和应用合适的解决方案。书中提到，尽管JMS和JCA提供了规范性的指导，但如果没有足够的时间和精力去深入理解它们的工作原理和实际操作，对于新手来说可能显得抽象且不易理解。本书的主要内容围绕Spring框架展开，Spring Integration是Spring生态系统中的一个重要组成部分，它简化了企业应用程序之间的通信，支持异步消息传递、事件驱动架构、服务总线等关键功能。通过Just Spring Integration，作者试图提供一个实践导向的教程，帮助读者掌握如何使用Spring框架来构建高效、灵活和可维护的企业级集成系统。书中不仅涵盖了Spring Integration的基本概念和技术，还深入剖析了其设计模式和最佳实践，包括如何配置消息代理、处理消息路由、事务管理以及错误处理等。此外，作者还可能介绍了与其他Spring模块（如Spring Boot、Spring Cloud等）的集成，以便读者能够全面理解Spring框架在企业集成场景中的整体应用。对于想要进入企业级开发、特别是使用Spring进行消息集成的开发者来说，《Just Spring Integration》是一本不可或缺的参考书。它不仅提供了理论知识，还提供了实际项目中的实践经验，使得学习者能够更快地适应企业级项目的需求，降低学习曲线，提高工作效率。修订历史部分显示，这本书于2012年3月30日首次发布，并持续更新以反映最新的技术发展。对于想要获取更具体版本信息和勘误表的读者，可以通过访问O'Reilly Media网站查询。《Nutshell Handbook》、Nutshell Handbook logo以及O'Reilly logo都是O'Reilly Media的注册商标，表明这是一本权威且具有高质量内容的技术手册。

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页未读，继续阅读

zhangzhongke007

粉丝: 68
资源: 54

Just Spring Integration：初学者指南到企业级消息架构

深入理解Hibernate：Madhusudhan Konda著

Just Spring：权威指南

Just Spring - 掌握Java开发者的核心技术

spring Integration 介绍

Just Spring Data Access

Just Spring - 入门指南

Just Spring Data Access 深入解析

Just Spring入门教程：简洁清晰的英文版指南

Just Spring：基础到高级概念

《Just Spring》：Java开发者指南，深入讲解Spring框架与依赖注入

最新资源