Spring 3.0深度指南：实战构建高效J2EE应用

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

《Spring in Action: Third Edition》是一本针对Spring 3.0进行全面更新的实战指南，它深入浅出地介绍了这个流行的框架，涵盖了最新的特性、工具和技术实践。书中通过一系列简短的代码示例和贯穿全书的开发案例，帮助读者学习如何构建高效、简洁的J2EE应用程序。本书由Jerry等作者撰写，特别强调了Spring的核心模块，如Spring MVC用于构建Web应用，RESTful服务的支持，以及Spring Security的安全功能。Web Flow部分则探讨了如何利用Spring进行业务流程管理。此外，还涉及了事务管理、数据库操作、远程服务集成、RESTful API的构建、消息传递、JMX对Spring bean的管理等内容，全面覆盖了Spring在企业级应用中的各种应用场景。作者以“探索Spring的核心模块”开篇，阐述了如何通过Spring的组件化思想（即bean）实现应用对象的解耦，以及如何利用面向切面编程（AOP）处理跨切面关注点，如日志记录、事务管理等。Spring的bean容器是整个框架的基础，它通过依赖注入（Dependency Injection）模式管理对象之间的关系，提高了代码的灵活性和可维护性。书中章节分布合理，从基础的Spring入门（如Springing into action）到高级主题，如利用JMX进行bean的动态监控，无不体现作者对Spring框架深度理解。对于新手来说，这是一本理想的入门书籍；而对于经验丰富的开发者，则能从中找到新的视角和实践技巧。《Spring in Action: Third Edition》不仅提供理论知识，还提供了丰富的实战案例，让读者能够边学边做，迅速掌握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页未读，继续阅读

zhxsg

粉丝: 7
资源: 7

Spring 3.0深度指南：实战构建高效J2EE应用

Manning.Spring.in.Action.4th.Edition.2014.11.epub

Spring in Action, Third Edition 文字版

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

spring.thymeleaf.prefix=classpath:/templates/ spring.thymeleaf.suffix=.html spring.thymeleaf.cache=false spring.thymeleaf.mode=LEGACYHTML5

spring.application.name: srm-eureka spring.profiles.active: localhost spring.security.user.name: demo spring.security.user.password: 123abcd

spring.data.redis.host和 spring.redis.host的区别

spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning

最新资源