Spring核心技术解析：第三版

需积分: 10 101 浏览量更新于2024-07-28 收藏 4.24MB PDF 举报

"Spring in Action 3rd Edition" 《Spring in Action 第三版》是一本深入探讨Spring框架的专业书籍，由Craig Walls撰写。该书详细介绍了Spring的核心特性、应用程序基础以及与其他技术的集成，旨在帮助读者掌握Spring的强大功能。书中涵盖了从Spring的基本概念到实际应用的多个关键领域。在"Part1 Core Spring"部分，作者首先引导读者进入Spring的世界，解释了Spring的核心模块是如何工作的。Spring框架的核心在于其bean容器，它允许开发者解耦应用程序对象，实现松耦合设计。这一部分还讨论了如何使用Spring来管理跨切面的关注点（AOP），即通过面向切面编程来处理如日志、事务等通用任务，以减少代码的重复和复杂性。 "2. Wiring beans"章节深入讲解了如何配置和连接Spring中的bean，包括XML配置和基于注解的配置方式，以及如何最小化XML配置，提高代码的可读性和可维护性。 "3. Minimizing Spring configuration XML"则关注于如何更高效地管理Spring配置，减少XML文件的冗余，提高开发效率。 "4. Aspect-oriented Spring"介绍了Spring的AOP支持，让读者理解如何使用切面来封装横切关注点，并将其与业务逻辑分离。在"Part2 Spring application essentials"中，书籍讨论了与数据库交互和事务管理，包括"5. Hitting the Database"和"6. Managing transactions"，这两部分讲述了如何利用Spring的数据访问抽象层和声明式事务管理，简化数据操作和确保事务的一致性。 "7. Building web applications with Spring MVC"部分涉及构建基于Spring的Web应用程序，重点是Spring MVC框架，它是Spring用于构建Web应用的核心组件。 "8. Spring WebFlow"章节介绍了Spring WebFlow，这是一个用于构建流程导向Web应用的工具，可以更好地管理用户会话和页面导航。 "9. Securing Spring"讨论了如何使用Spring的安全特性来保护应用程序，防止未经授权的访问。 "Part3 Integrating Spring"涵盖了Spring与其他技术的集成，如"10. Working with remote services"展示了如何与远程服务通信，"11. Giving Spring some REST"涉及RESTful服务的实现，"12. Messaging in Spring"讲解了Spring对消息传递的支持，"13. Managing Spring beans with JMX"则介绍了如何通过Java Management Extensions (JMX)来管理和监控Spring bean。最后的"14. Odds and ends"章节包含了各种其他主题，可能是关于Spring的高级特性和最佳实践。《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页未读，继续阅读

gjjyusha

粉丝: 0
资源: 5

Spring核心技术解析：第三版

【Spring in Action 3rd Edition】 pdf

Manning Spring in Action 3rd Edition pdf

Spring in Action 3rd Edition Craig Walls

Spring in Action 3rd Edition.pdf

Spring in Action 3rd Edition_spring_action_barnpmd_

spring in action(3rd Edition)

Spring in action 3rd (第三版)

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

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

Spring in Action, Third Edition 文字版

最新资源