Spring 3实战指南：核心模块与应用集成详解

5星 · 超过95%的资源需积分: 10 60 浏览量更新于2024-07-25 收藏 4.24MB PDF 举报

《Spring in Action 第三版》是一本深入讲解Spring框架的经典教程，由作者Craig Walls撰写。本书在2010年10月26日进行了最后的保存更新，作为MEAP（Manning Early Access Program）的一部分，它为读者提供了丰富的Spring框架实战知识。本书共分为三个部分，每个部分涵盖了Spring的核心概念和技术。第一部分"Core Spring"，从入门开始，包括章节如： 1. "Springing into action"：介绍Spring框架的基本理念和优势，以及它如何提升Java应用程序的开发效率。 2. "Wiring beans"：讲解依赖注入（Dependency Injection），它是Spring的重要特性，用于管理和管理应用程序对象之间的关系。 3. "Minimizing Spring configuration XML"：探讨如何通过减少XML配置来简化应用的维护和扩展。 4. "Aspect-oriented Spring": 探索面向切面编程（AOP），如何处理跨切面关注点，如日志记录、事务管理等。第二部分"Spring application essentials"，涉及核心应用技术： 5. "Hitting the Database": 明确如何使用Spring进行数据库操作，包括数据访问层设计。 6. "Managing transactions"：讲解Spring的事务管理机制，确保数据一致性。 7. "Building web applications with Spring MVC": 介绍如何利用Spring MVC构建现代web应用程序，实现松耦合和模块化。 8. "Spring WebFlow": 介绍Spring Web Flow，一种基于状态机的用户界面控制框架。 9. "Securing Spring": 安全性是关键，这里涵盖Spring的安全措施，如身份验证和授权。 10. "Working with remote services": 探讨如何与远程服务集成，包括RESTful服务的使用。 11. "Giving Spring some REST": 实现RESTful API设计，利用Spring支持HTTP协议。 12. "Messaging in Spring": 显示如何在Spring中处理消息传递，包括AMQP和JMS。 13. "Managing Spring beans with JMX": 介绍使用Java Management Extensions (JMX) 进行Spring应用的监控和管理。 14. "Odds and ends": 收录了一些实用技巧和额外的高级主题，帮助读者解决实际项目中的问题。这本书不仅适合初学者了解Spring的基础，也对有经验的开发人员提供深入的技术指导。通过阅读《Spring in Action 第三版》，开发者可以掌握如何有效地使用Spring框架构建可维护、高扩展性和高性能的Java应用程序。

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

huangning2

粉丝: 13
资源: 70

Spring 3实战指南：核心模块与应用集成详解

《Spring in Action 第三版》英文高清版

《Spring实战》第三版PDF参考资料概览

Spring in Action 第三版：精通Spring 3.0

Spring.in.Action.3rd.Edition.zip

【Spring in Action 3rd Edition】 pdf

Manning.Spring.in.Action.3rd.Edition

Spring in Action 3rd Edition

Spring in Action 3rd Edition Craig Walls

Spring in Action 3rd Edition_spring_action_barnpmd_

spring in action(3rd Edition)

最新资源