Spring Boot Messaging 教程：企业与集成解决方案

需积分: 9 104 浏览量更新于2023-05-30 收藏 6.39MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"Spring Boot Messaging 无水印pdf" Spring Boot Messaging 是一本专注于Spring Boot在企业级消息传递和集成解决方案中的应用书籍，由Felipe Gutierrez撰写。这本书详细介绍了如何使用Spring Boot来处理和集成各种消息传递APIs，帮助开发者构建高效、可扩展的系统。在Spring Boot框架中，消息传递是一个关键组件，它允许应用程序之间以及应用程序与外部系统之间的异步通信。Spring Boot Messaging支持多种消息中间件，如RabbitMQ、Kafka、ActiveMQ等，这些中间件在大型分布式系统中扮演着重要角色，用于处理高并发和数据流处理。书中可能涵盖了以下核心知识点： 1. **Spring Integration**：Spring Boot集成Spring Integration，一个强大的框架，用于构建企业级应用的集成解决方案。它提供了一套丰富的适配器，可以与各种协议、文件系统、数据库等进行交互。 2. **AMQP（Advanced Message Queuing Protocol）**：RabbitMQ是基于AMQP的，Spring Boot通过Spring AMQP提供对RabbitMQ的支持。书中可能讲解了如何配置RabbitMQ，创建消息队列，以及生产者和消费者之间的通信。 3. **Apache Kafka**：Spring Boot也支持Kafka，一个分布式流处理平台。这部分可能会介绍如何使用Spring for Apache Kafka API发送和接收消息，以及设置Kafka的配置。 4. **JMS（Java Message Service）**：Spring Boot通过JMS API与消息代理（如ActiveMQ）进行交互。这部分内容可能包括创建消息、连接工厂、消息监听器等。 5. **WebSocket**：Spring Boot支持WebSocket协议，可用于实时双向通信。书里可能会讲述如何实现WebSocket服务器端和客户端，以及在Spring Boot应用中集成WebSocket。 6. **Event-driven Architecture**：书中可能讨论了事件驱动架构在Spring Boot中的应用，如何利用消息传递来实现解耦和响应式编程。 7. **错误处理和监控**：如何处理消息传递过程中的异常，以及使用Spring Boot Actuator等工具进行性能和健康检查。 8. **实战示例**：书中可能包含多个实际项目案例，展示如何在实际环境中应用上述概念和技术。 9. **最佳实践和设计模式**：作者可能分享了一些最佳实践，帮助读者理解如何有效地使用Spring Boot Messaging来构建健壮和可维护的系统。 Spring Boot Messaging这本书为开发者提供了深入理解Spring Boot中消息传递机制的全面指南，是学习和掌握Spring Boot集成消息服务的宝贵资源。通过阅读这本书，开发者可以提升在企业级应用开发中的消息处理能力，实现高效的数据交换和系统集成。

资源详情

资源推荐

CHAPTER 1 ■ MESSAGING

Messaging Models and Messaging Patterns

Some messaging models were established when messaging became a part of all systems. These

models, in my opinion, evolved into the creation of messaging design patterns.

Point-to-Point

A point-to-point model is a way to send a message to a queue (First In, First Out), whereby only

one receiver gets the message. See Figure1-2.

SENDER

QUEUE

RECEIVER

Figure 1-2. Point-to-point model

PUBLISHER

SUBSCRIBER

TOPIC

SUBSCRIBER

Figure 1-3. Publish–subscribe model

The point-to-point model is also used as a message channel pattern, whereby instead of a

queue, you have a channel (which is a way to transport your message). It still guarantees that only

one receiver gets the message in the order it was sent.

You’ll see some examples later in the book about these models and patterns.

Publish-Subscribe

The publish-subscribe model describes a publisher that sends a message (a topic) to multiple

subscribers of that topic. Each subscriber will receive only one copy of the message. See Figure1-3.

The publish-subscribe model is also used as a message channel pattern, whereby instead of a

topic, you have a channel that delivers a copy of the message to its subscribers.

These models are more related to the JMS (Java Messaging System) and are important to

understand because they form the basics of all enterprise systems.

CHAPTER 1 ■ MESSAGING

Messaging Patterns

A design pattern is a solution to a commonly known problem in the software design. By the same

token, messaging patterns attempt to solve problems with messaging designs.

You will learn about the implementation of the following patterns during the course of this

book, so I want to list them here with simple definitions to introduce them:

• Message type patterns: Describe different forms of messaging, such as string

(maybe plain text, JSON and/or XML), byte array, object, etc.

• Message channel patterns: Determine what kind of a transport (channel)

will be used to send a message and what kind of attributes it will have.

The idea here is that the producer and consumer know how to connect to

the transport (channel) and can send and receive the message. Possible

attributes of this transport include a

request-reply feature and a unidirectional channel, which you will learn

about very soon. One example of this pattern is the point-to-point channel.

• Routing patterns: Describe a way to send messages between producer and

consumers by providing a routing mechanism (filtering that’s dependent on

a set of conditions) in an integrated solution. That can be accomplished by

programming, or in some cases, the messaging system (the broker) can have

these capabilities (as with RabbitMQ).

• Service consumer patterns: Describe how the consumers will behave when

messages arrive, such as adding a transactional approach when processing

the message. There are frameworks that allow you to initiate this kind

of behavior (like the Spring Framework, which you do by adding the @

Transactional, a transaction-based abstraction).

• Contract patterns: Contracts between the producer and consumer to have

simple communications, such as when you do some REST calls, where you

call a JSON or XML message with some fields.

• Message construction patterns: Describe how a message is created so it

can travel within the messaging system. For example, you can create an

“envelope” that can have a body (the actual message) and some headers

(with a correlation ID or a sequence or maybe a reply address). With a

simple web request, you can add parameters or headers and the actual

message becomes the body of the request, making the whole request part

of the construction pattern. The HTTP protocol allows for that kind of

communication (messaging).

• Transformation patterns: Describe how to change the content of the

message within the messaging system. Think about a message that requires

some processing and needs to be enhanced on the fly, such as a content

enricher.

As you can see, these patterns not only describe the messaging process but some of them

describe how to handle some of the common use cases you saw earlier. Of course, there are a lot

more messaging patterns, and these are just a few that we are going to explore in this book.

CHAPTER 1 ■ MESSAGING

If you want more information, I recommend that you visit the Enterprise Integration Patterns

web site, http://www.enterpriseintegrationpatterns.com/. Also check out this must-read

book—Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions by

Gregor Hohpe and Bobby Woolf, from Addison-Wesley.

In the book, I cover some of these patterns using the Spring Integration module and various

messaging systems (brokers).

Messaging with Spring Framework

The Spring Framework is one of the most commonly used frameworks by the Java community.

The Spring Framework has enabled a simple and easy way to do messaging, by implementing

a template design pattern that can be used with any messaging system. It supports the JMS API

with the JmsTemplate, the AMQP with the RabbitTemplate, STOMP, and internal messaging with

events and listeners. Don’t worry, we will cover all of these later in book.

It’s worth mentioning that the Spring Integration project has been well accepted by the

community, and the core of the Spring Integration (messaging, channels, and other interfaces)

has been part of the Spring Core since version 4.0.

There are many good messaging frameworks out there. Some of them use pure Java, and

others depend on the Spring Framework. The Spring team has been working very hard to make it

even easier for its developers to use all the features, including concurrency, transactions, retries,

etc. To use other libraries, you have to implement them by hand using the same logic.

■ Note You can download the book’s source code from the Apress site or you can clone it from this GitHub

repository: https://github.com/felipeg48/spring-messaging.

Summary

This chapter introduced messaging and the messaging systems. You read about the basic concept

of messaging, whereby developers need to send information from one point to another.

The chapter reviewed some use cases, models, and patterns of messaging. The book

will cover them in more detail and use them via some of the best implementations out there,

including the Spring Framework and some of their modules, including Spring Integration, Spring

AMQP, and Spring Cloud Stream.

The next chapter includes a tour of Spring Boot, which is the next generation of creating

enterprise-ready Spring applications. Spring Boot is the base for all the modules you use in this book.

F. Gutierrez, Spring Boot Messaging, DOI 10.1007/978-1-4842-1224-0_2

CHAPTER 2

Spring Boot

I’ll start with a phrase that I wrote in another book: Spring Boot is a new chapter in creating

enterprise-ready applications with the Spring Framework.

Spring Boot does not replace the Spring Framework; you can see it as a new way to create

awesome applications with the framework used by the Java community.

In this chapter, I show you what Spring Boot is and how it works behind the scenes. You will

also see the power of Spring Boot with a small example. So why do we need to look at Spring Boot?

First of all, all the technologies that we are going to use, such as Spring Integration, Spring AMQP,

Spring Cloud Stream, and others, use Spring Boot as their base. All the examples in this book use

Spring Boot to create Spring apps. And of course, Spring Boot makes messaging even easier.

What Is Spring Boot?

To begin with, Spring Boot is an opinionated technology. What does that mean?

Spring Boot looks at the classpath and tries to determine what kind of application you are

trying to run. For example, if you have the spring-mvc modules in your classpath, Spring Boot

will wire up the WebApplicationInitializer and DispatcherServlet classes inside the Spring

container and will set up an embedded container (Tomcat by default), so you can run your

application without having to copy or deploy your application to a servlet container.

Spring Boot’s Features

Let’s look at the most important Spring Boot features:

• It can create standalone Spring applications. Based on its Maven or Gradle

plugin, you can create executable JARs or WARs.

• It has an opinionated technology based on the starter poms.

• Includes auto-configuration, which will configure your Spring application

without any XML or Java config classes.

• Includes embedded servlet containers for web apps (Tomcat, Jetty, or

Undertow).

• Includes production-ready features (non-functional requirements) that are

ready to use, such as metrics and health checks.

CHAPTER 2 ■ SPRING BOOT

• Spring Boot is not a plugin or a code generator (this means that Spring Boot

doesn’t create a file to be compiled).

• If you have an application or servlet container, you can deploy Spring Boot

as a WAR without making any changes.

• You can access all the Spring application events and listeners (something

that we will discuss in the next chapter).

This list is just a few features of what Spring Boot can offer; of course there are more. I recommend

my other book—Pro Spring Boot from Apress—if you need to know more about it. That book includes

more comprehensive and detailed sections about how Spring Boot works internally.

Restful API with Spring Boot

One of the important features of Spring Boot is that you can create executable JARs and run them

by just executing java -jar yourapp.jar. You can also create executable WARs (web archive)

that can run standalone (using the embedded container within the WAR) or deploy them to a

servlet container without chaining anything in your code.

This section shows you a Restful API that lists the currency and the rates based on the country

code. This project is a Spring Boot web application.

■ Note You can find a download link for all the source code at the http://www.apress.

com/9781484212257.

I’ll show you some code snippets of the application, so you have an idea of what Spring Boot

can do with very minimal code and no configuration files.

I’m assuming that you already have the code. I suggest that you use the STS (Spring Tool Suite),

which you can get from https://spring.io/tools/sts/all. I use this IDE because it has very nice

features for running Spring Boot, and all the figures that you see are based on this IDE, but you can

choose any IDE you like.

The rest-api-demo Project

This project is a Spring Boot web application that will expose Restful endpoints that will show a

country currency and the rates of other countries. This project is in the folder named ch02.

This project also uses the JPA (Java Persistence API) with an in-memory database (using the

H2 engine), AOP (Aspect-Oriented Programming). The exposed endpoints are listed in Table2-1.

剩余205页未读，继续阅读

yinkaisheng-nj

粉丝: 763
资源: 6952

会员权益专享

Spring Boot Messaging 教程：企业与集成解决方案

spring-boot-reference.pdf

《Spring Boot 实战》PDF 下载

《SpringBoot实战(第4版)》PDF

基于Spring Boot旅游网站参考文献

spring boot 在线聊天功能

给我一个spring boot官方文档WebSocket部分的中文翻译

org.springframework.messaging

springboot近三年的参考文献

Spring Boot

spring boot

Monaco edit 如何对接eclipse.jdt.ls。我后台是spring boot。前端是vue+Monaco edit

spring boot有哪些层

spring boot tesseract-ocr

关于springboot的英文文献

spring boot 集成rocketmq

spring boot 集成mq

Spring Boot应用程序使用Maven进行构建，指定私信功能模块的依赖是哪个

请用spring boot 写一个websocket客户端

请为我找到几个基于spring boot的优秀开源项目

spring boot 事件驱动 远程调用

会员权益专享

最新资源

spring boot 事件驱动远程调用