Spring核心模块解析：第三版精华概览

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

"Spring in Action 第3版 2011" Spring in Action 是一本由 Craig Walls 编写的关于 Spring 框架的经典书籍，第三版发布于2011年。这本书深入浅出地介绍了 Spring 框架的核心概念、应用基础以及与其他技术的集成方法。以下是书中涵盖的一些关键知识点： 1. **核心Spring** - Spring框架的起源和发展：书中提到Spring最初是围绕Bean容器设计的，它旨在解决Java平台上的依赖注入问题，从而提高代码的可测试性和可维护性。 - 应用对象解耦：Spring通过依赖注入（Dependency Injection, DI）来减少组件之间的耦合，使得组件可以独立于其依赖项进行开发和测试。 - 面向切面编程（Aspect-Oriented Programming, AOP）：Spring支持AOP，允许开发者将横切关注点（如日志、事务管理）与业务逻辑分离，实现更整洁的代码结构。 2. **Spring Bean容器** - Bean的配置和管理：Spring使用XML或基于注解的方式进行Bean的配置，简化了应用程序的组装。书中详细讲解了如何最小化XML配置，以提高开发效率。 - 自动装配（Auto-Wiring）：Spring 提供了自动装配机制，根据类型或名称自动连接Bean之间的依赖关系，降低了手动配置的繁琐程度。 3. **数据访问与事务管理** - 数据库交互：Spring提供了一整套数据库访问的工具，包括JDBC抽象层，ORM（Object-Relational Mapping）集成，如Hibernate和MyBatis，使得数据库操作更加便捷和灵活。 - 事务管理：Spring提供了声明式事务管理，允许开发者在不关心底层实现的情况下处理事务，提高了事务处理的统一性和可靠性。 4. **Spring MVC和Web应用** - Spring MVC：Spring的Model-View-Controller框架，用于构建高性能、易于测试的Web应用。书中详细介绍了Spring MVC的工作原理和使用方法，包括控制器、模型、视图和处理器映射器等组件。 - Spring Web Flow：这是一个用于构建复杂Web交互流程的模块，帮助开发者管理用户会话和状态。 5. **安全和集成** - Spring Security：书中可能涉及Spring的安全特性，如身份验证、授权和会话管理，帮助开发者构建安全的应用。 - 远程服务集成：Spring支持与远程服务的集成，例如RMI、Hessian、 Burlap等协议。 - RESTful服务：Spring提供了创建RESTful API的支持，使得应用能够更好地与其他系统交互。 - 消息传递：Spring框架集成了JMS（Java Message Service），支持企业级的消息中间件通信。 - JMX管理：Spring还允许通过JMX（Java Management Extensions）对Spring应用进行监控和管理。这本书是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页未读，继续阅读

wupf86

粉丝: 0
资源: 33

Spring核心模块解析：第三版精华概览

《Spring in Action》第3版示例代码解析

Spring实战(第3版)：探索Spring 3.0

Spring 3.0实战指南：简化编程，聚焦业务

SPRING 实战（第3版） MOBI 版

Spring框架实战（第3版）

Spring实战指南（第3版）：核心模块与应用集成

Spring in action 3.0

spring-in-action-examples:Spring in Action Book（第 3 版）中的示例

Spring in Action, Third Edition 文字版

spring in action 3Ed 带源代码

最新资源