Spring in Action 第三版：核心技术与应用集成

下载需积分: 10 | PDF格式 | 3.98MB | 更新于2024-07-28 | 178 浏览量 | 举报

《Spring in Action 第三版》是一本由 Manning Publications 出版的专业IT书籍，旨在深入介绍Spring框架。作为Spring框架的权威指南，本书覆盖了Spring技术的核心概念、应用基础和集成策略，适合开发者系统理解和实践Spring在现代软件开发中的作用。 **第一部分：核心Spring** - **第1章：Springing into action**：本章将带领读者快速入门Spring，介绍其基本理念和优势，帮助理解为何选择Spring作为依赖注入和面向切面编程的解决方案。 - **第2章：Wiring beans**：讲解如何在Spring中配置和管理bean，包括bean的作用域、装配方式以及依赖关系的处理。 - **第3章：Minimizing Spring configuration XML**：探讨如何通过各种技术减少XML配置文件的复杂性，如使用Java配置或注解来简化配置过程。 - **第4章：Aspect-oriented Spring**：介绍Spring AOP（面向切面编程）的概念，演示如何利用它进行代码分离和横切关注点的处理。 **第二部分：Spring应用基础** - **第5章：Hitting the Database**：深入讨论Spring与数据库交互的方法，包括数据访问对象（DAO）模式和JDBC操作的整合。 - **第6章：Managing transactions**：讲解事务管理在Spring中的实现，包括如何配置事务策略和处理异常情况。 - **第7章：Building web applications with Spring MVC**：详细介绍如何使用Spring MVC构建高效、可扩展的Web应用程序架构。 - **第8章：Spring WebFlow**：介绍Spring Web Flow，一个强大的状态管理和工作流管理工具，用于简化复杂的业务流程控制。 - **第9章：Securing Spring**：涉及Spring的安全特性，包括身份验证、授权和安全配置，以保护应用程序免受攻击。 **第三部分：Spring集成** - **第10章：Working with remote services**：探讨Spring对远程服务调用的支持，包括RESTful服务和Web服务的集成。 - **第11章：Giving Spring some REST**：深入RESTful API设计，展示如何利用Spring的RestTemplate和WebSocket支持。 - **第12章：Messaging in Spring**：讲解Spring与消息传递技术（如JMS）的集成，帮助开发者构建消息驱动的系统。 - **第13章：Managing Spring beans with JMX**：阐述如何通过Java Management Extensions (JMX) 对Spring容器进行监控和管理。 - **第14章：Odds and ends**：总结并讨论一些边缘话题和最佳实践，提供全面的技术参考。在编写过程中，这本书曾经过多位作者和专家的精心打磨，不断吸收社区反馈，并鼓励读者在Manning-sandbox论坛上参与讨论和提出建议。该版本的版权信息表明，此书最终于2011年发布，适用于那些希望精通Spring技术的开发人员。如果你是本书的合法持有者，可以通过邮箱地址<jeffrey1979@gmail.com>获得许可。

with a mock implementation during testing. We were unable to adequately test

due to tight-coupling, but we can easily test DamselRescuingKnight

by giving it a mock implementation of , as shown inBraveKnight Quest

listing 1.5.

Listing 1.5 To test , we'll inject it with a mock .BraveKnight Quest

package com.springinaction.knights;

import static org.mockito.Mockito.*;

import org.junit.Test;

public class BraveKnightTest {

@Test

public void knightShouldEmbarkOnQuest() throws QuestException {

Quest mockQuest = mock(Quest.class);

BraveKnight knight = new BraveKnight(mockQuest);

knight.embarkOnQuest();

verify(mockQuest, times(1)).embark();

}

Here I'm using a mock object framework known as Mockito to create a mock

implementation of the interface. With the mock object in hand, I create aQuest

new instance of injecting the mock via the constructor.BraveKnight Quest

After calling the method, I ask Mockito to verify that theembarkOnQuest()

mock 's method was called exactly one time.Quest embark()

Create a mock

Quest.

Inject the mock

Quest.

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=573

Licensed to ! ?? <jeffrey1979@gmail.com>

</bean>

<bean id="quest"

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

</beans>

This is just a simple approach to wiring beans in Spring. Don't concern yourself

too much with the details right now. We'll dig more into Spring configuration and

see what's going on when we get to chapter 2. We'll also look at other ways that we

can wire beans in Spring.

Now that we've declared the relationship between and a BraveKnight

, we need to load up the XML configuration file and kick off theQuest

application.

In a Spring application, an application context loads bean definitions and wires

them together. The Spring application context is fully responsible for the creation

of and wiring of the objects that make up the application. Spring comes with

several implementations of its application context, each primarily differing only in

how they load their configuration.

Because the beans in knights.xml are declared in an XML file, an appropriate

ch oic e fo r ap pli cat ion con tex t mi ght be

. This Spring context implementationClassPathXmlApplicationContext

loads the Spring context from one or more XML files located in the application's

classpath. The main() method in listing 1.7 uses

to load knights.xml and to get aClassPathXmlApplicationContext

reference to the object.Knight

Listing 1.7 KnightMain.java loads the Spring application context and invokes the

knight's method.embarkOnQuest()

package com.springinaction.knights;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class KnightMain {

public static void main(String[] args) {

ApplicationContext context =

new ClassPathXmlApplicationContext("knights.xml");

Knight knight = (Knight) context.getBean("knight");

Inject the quest

bean.

Create a

SlayDragonQuest.

Load the Spring

context

Get the knight bean

SEEING IT WORK

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=573

Licensed to ! ?? <jeffrey1979@gmail.com>

knight.embarkOnQuest();

}

Here the method creates the Spring application context based on themain()

knights.xml file. Then it uses the application context as a factory to retrieve the

bean whose ID is "knight". With a reference to the object, it simply callsKnight

the method to have the quest embark on the quest that it wasembarkOnQuest()

given. Notice that this class knows nothing about which type of our heroQuest

has. For that matter it is blissfully unaware of the fact that it's dealing with

. Only the knights.xml file knows for sure what theBraveKnight

implementations are.

And with that you have a quick introduction to dependency injection. You'll see

a lot more DI throughout this book. But if you want even more dependency

injection, then I encourage you to have a look at Dhanji R. Prasanna's

"Dependency Injection", which covers DI in fine detail.

But now let's have a look at another of Spring's Java-simplifying strategies:

Declarative programming through aspects.

Although DI makes it possible to tie software components together loosely,

aspect-oriented programming enables you to capture functionality that is used

throughout your application in reusable components.

Aspect-oriented programming is often defined as a programming technique that

promotes separation of concerns within a software system. Systems are composed

of several components, each responsible for a specific piece of functionality. Often,

however, these components also carry additional responsibility beyond their core

functionality. System services such as logging, transaction management, and

security often find their way into components whose core responsibility is

something else. These system services are commonly referred to as cross-cutting

concerns because they tend to cut across multiple components in a system.

By spreading these concerns across multiple components, you introduce two

levels of complexity to your code:

The code that implements the systemwide concerns is duplicated across multiple

components. This means that if you need to change how those concerns work, you’ll

need to visit multiple components. Even if you’ve abstracted the concern to a separate

module so that the impact to your components is a single method call, that single method

call is duplicated in multiple places.

Your components are littered with code that isn’t aligned with their core functionality. A

Use the knight

1.1.3 Applying aspects

http://www.manning-sandbox.com/forum.jspa?forumID=573

Licensed to ! ?? <jeffrey1979@gmail.com>

剩余479页未读，继续阅读

身份认证购VIP最低享 7 折!

30元优惠券

luna_hk

粉丝: 0

Spring in Action 第三版：核心技术与应用集成

Spring in Action,ThirdEdition 英文第三版

Spring in Action 第三版：核心技术与应用探索

DevelopingWebServicesWithCXFandAxis2ThirdEdition

Real-Time Rendering_ThirdEdition_Colorful__实时渲染第三版彩图版

Spring Action (3rd)

深入理解C# 英文版(高清)

数字图像处理（第三版）（英文版）彩图

Thinking in Java mobi

《JavaServerPagesTM,ThirdEdition》-JSP技术英文文献与翻译

CSAPP第三版扫描版：计算机系统编程者视角

最新资源