Spring实战第三版：核心模块与应用集成详解

5星 · 超过95%的资源 | 下载需积分: 10 | PDF格式 | 4.24MB | 更新于2024-07-25 | 139 浏览量 | 举报

《Spring in Action 第三版》是一本深入介绍Spring框架的经典技术书籍，由Craig Walls撰写。该书于2010年通过Manning Early Access Program (MEAP) 发布，旨在帮助读者全面理解和掌握Spring框架在现代软件开发中的应用。本书分为三个主要部分，涵盖了Spring的核心模块、高级特性以及与其他技术的集成。 **第一部分：核心Spring** - **第1章：Springing into action**：介绍了Spring框架的起源和发展，以及它如何成为Java开发中的关键组件。 - **第2章：Wiring beans**：阐述了如何使用Spring容器进行依赖注入（Dependency Injection），这是Spring的核心概念，有助于实现松耦合。 - **第3章：Minimizing Spring configuration XML**：讲解如何优化XML配置，减少重复和冗余，提高代码可维护性。 - **第4章至第14章：Aspect-oriented programming (AOP)**：涉及面向切面编程，用于处理如事务管理、安全性、远程服务调用等跨层关注点。 **第二部分：Spring应用程序基础** - **第5章：Hitting the Database**：探讨Spring与数据库交互的最佳实践，包括数据访问对象（DAO）模式。 - **第6章：Managing transactions**：详细解释了Spring如何管理和协调数据库操作的事务处理。 - **第7章：Building web applications with Spring MVC**：展示了如何利用Spring MVC构建可扩展的Web应用程序架构。 - **第8章：Spring Web Flow**：介绍了Spring Web Flow，一个用于创建复杂业务流程的工具。 - **第9章：Securing Spring**：讲解如何使用Spring进行安全防护，包括身份验证和授权。 - **第10章至第12章：Integrating with remote services**：涵盖了Spring对SOAP和RESTful服务的支持，以及消息传递机制。 - **第11章：Giving Spring some REST**：演示如何利用Spring与RESTful API进行交互。 - **第12章：Messaging in Spring**：讲解Spring在企业消息队列和事件驱动架构中的应用。 - **第13章：Managing Spring beans with JMX**：介绍如何使用Java Management Extensions (JMX) 监控和管理Spring应用中的bean实例。 - **第14章：Odd and ends**：总结了其他实用技巧和最佳实践，可能包括异常处理和性能优化等内容。 **第三部分：整合Spring** 这部分深入探讨Spring与其他技术的集成，例如企业服务总线（ESB）、消息中间件和其他框架，以增强应用程序的功能和可扩展性。《Spring in Action 第三版》是开发人员不可或缺的参考资料，无论你是刚接触Spring的新手还是经验丰富的开发者，都能从中获得丰富的学习和实践指导。书中详细的技术剖析和实战案例使得理论知识与实践经验相结合，能够帮助读者更好地理解和运用Spring框架来构建高效、灵活的现代应用程序。

Figure 1.3 Using AOP, systemwide concerns blanket the components that they impact. This

leaves the application components to focus on their specific business functionality.

To demonstrate how aspects can be applied in Spring, let’s revisit the knight

example, adding a basic Spring aspect to the mix.

Anyone who knows anything about knight only knows about knights because their

deeds were chronicled in song by the musically-inclined story tellers known as

minstrels. Let's suppose that we want to record the comings and goings of our

using the services of a minstrel. Listing 1.8 shows the BraveKnight Minstrel

class we might use.

Listing 1.8 A is a musically inclined logging system of medieval times.Minstrel

package com.springinaction.knights;

public class Minstrel {

public void singBeforeQuest() {

System.out.println("Fa la la; The knight is so brave!");

}

public void singAfterQuest() {

System.out.println(

"Tee hee he; The brave knight did embark on a quest!");

}

As you can see, is a rather simple class with two methods. The Minstrel

method is intended to be invoked before a knightsingBeforeQuest()

To be called before

a quest

AOP IN ACTION

Licensed to Mark Wickens <mark@wickensonline.co.uk>

embarks on a quest and the method should be invokedsingAfterQuest()

after the knight has completed a quest. It should be pretty simple to work this into

our code, so let's make the appropriate tweaks to to use the BraveKnight

. Listing 1.9 shows our first attempt.Minstrel

Listing 1.9 The has been modified to call methods before andBraveKnight Minstrel

after embarking on a quest.

package com.springinaction.knights;

public class BraveKnight implements Knight {

private Quest quest;

private Minstrel minstrel;

public BraveKnight(Quest quest, Minstrel minstrel) {

this.quest = quest;

this.minstrel = minstrel;

}

public void embarkOnQuest() throws QuestException {

minstrel.singBeforeQuest();

quest.embark();

minstrel.singAfterQuest();

}

That should do the trick. But something doesn't seem right here. Is it really

within the knight's range of concern to manage his minstrel? It seems to me that a

minstrel should just do its job without the knight asking it to do so. After all, that's

the minstrel's job--to sing about the knight's endeavors. Why should the knight

have to keep reminding the minstrel to do its job?

Furthermore, because the knight needs to know about the minstrel, we're forced

to inject the into the . This not only complicates the Minstrel BraveKnight

's code, but also makes me wonder if we'd ever want a knight whoBraveKnight

didn't have a minstrel. What if the is ? Should we introduceMinstrel null

some -checking logic to cover that case?null

Our simple class is starting to get a bit more complicated andBraveKnight

will become more so if we were to handle the scenario. Butnull Minstrel

using AOP, we can declare that the minstrel should sing about a knight's quests and

free the knight from having to deal with the methods directly.Minstrel

To turn into an aspect, all we need to do is declare it as one in theMinstrel

Spring configuration file. Listing 1.10 shows the updated knights.xml file, updated

to declare as an aspect.Minstrel

Should a knight

manage its own

Minstrel?

Licensed to Mark Wickens <mark@wickensonline.co.uk>

Listing 1.10 Declaring to be an aspect so that the won't haveMinstrel BraveKnight

to keep reminding the to sing.Minstrel

<?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:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<constructor-arg ref="quest" />

</bean>

<bean id="quest"

class="com.springinaction.knights.SlayDragonQuest" />

<bean id="minstrel"

class="com.springinaction.knights.Minstrel" />

<aop:config>

<aop:aspect ref="minstrel">

<aop:pointcut id="embark"

expression="execution(* *.embarkOnQuest(..))" />

<aop:before pointcut-ref="embark"

method="singBeforeQuest"/>

<aop:after pointcut-ref="embark"

method="singAfterQuest"/>

</aop:aspect>

</aop:config>

</beans>

Here I'm using Spring's "aop" configuration namespace to declare that the

bean is an aspect. First, I had to declare the as a bean.Minstrel Minstrel

Then I refer to that bean in the element. Defining the aspect<aop:aspect>

further, I declare (using ) that before the <aop:before> embarkOnQuest()

method is executed, that the 's should beMinstrel singBeforeQuest()

called. This is called . And I (using ) declare that the before advice <aop:after>

method should be called after hassingAfterQuest() embarkOnQuest()

executed. This is known as .after advice

In both cases, the attribute refers to a pointcut namedpointcut-ref

"embark". This pointcut is defined in the preceding element with an<pointcut>

attribute set to select where the advice should be applied. Theexpression

expression syntax is AspectJ's pointcut expression language.

Don't worry if you don't know AspectJ or the details of how AspectJ pointcut

Declare the

Minstrel bean

Define a pointcut

Declare before

advice

Declare after

advice

Licensed to Mark Wickens <mark@wickensonline.co.uk>

expressions are written. We'll talk more about Spring AOP later in chapter 4. For

now it's enough to know that we've asked Spring to call the 's Minstrel

and methods before and after thesingBeforeQuest() singAfterQuest()

embarks on a quest.BraveKnight

That's all there is to it! With a tiny bit of XML, we've just turned Minstrel

into a Spring aspect. Don't worry if this doesn't make complete sense yet--you'll

see plenty more examples of Spring AOP in chapter 4 that should help clear this

up. For now, there are two important points to take away from this example.

First, is still a POJO--there's nothing about it that indicates that it isMinstrel

to be used as an aspect. Instead became an aspect when we declared itMinstrel

as such in the Spring context.

Second, and most important, can be applied to the Minstrel BraveKnight

without the needing to explicitly call on it. In fact, BraveKnight

remains completely unaware of the 's existence.BraveKnight Minstrel

I feel that I should also point out that although I used some Spring magic to turn

into an aspect, it was declared as a Spring first. The pointMinstrel <bean>

here is that you can do anything with Spring aspects that you can do with other

Spring beans, such as injecting them with dependencies.

Using aspects to sing about knights can be a lot of fun. But Spring's AOP can

be used for even more practical things. As you'll see later, Spring AOP can be

employed to provide services such as declarative transactions (chapter 7) and

security (chapter 10).

But for now, let's look at one more way that Spring simplifies Java

development.

Have you ever written some code and then felt like you had already written the

same code before? That's not deja vu, my friend. That's boilerplate code--the code

that you often have to write over and over again to accomplish common and

otherwise simple tasks.

Unfortunately, there are a lot of places where Java APIs involve a lot of

boilerplate code. A common example of boilerplate code can be seen when

working with JDBC to query data from a database. For example, If you've ever

worked with JDBC before, then you've probably written something similar to the

code in listing 1.11.

Listing 1.11 Many Java APIs, such as JDBC, involve writing a lot of boilerplate

1.1.4 Eliminating boilerplate code with templates

Licensed to Mark Wickens <mark@wickensonline.co.uk>

剩余466页未读，继续阅读

dupuliu

粉丝: 0

Spring实战第三版：核心模块与应用集成详解

Spring in Action 第三版 英文版

Spring In Action 第三版及源码

Spring in Action 第四版英文PDF

spring in action 第三版

Spring in Action5 chm

spring cloud in action

manning.spring.in.action.4th.edition

Spring Boot in Action里某段介绍Spring Boot的内容

spring security in action

spring microservices in action 电子书

最新资源

Spring in Action 第三版英文版