Spring实战第三版核心特性与整合指南

需积分: 9 172 浏览量更新于2024-07-24 收藏 3.98MB PDF 举报

"Spring in Action, Third Edition" 是一本关于Spring框架的专业书籍，涵盖了Spring的核心功能、应用程序基础以及与其他技术的集成。本书分为三个部分： Part I: Core Spring 1. Springing into action：这部分介绍了Spring框架的基础知识，包括Spring如何简化Java企业级应用开发，以及它的核心理念和架构。 2. Wiring beans：详细讲解了Spring的依赖注入（Dependency Injection）机制，如何通过XML或注解方式配置和连接Bean。 3. Minimizing Spring configuration XML：讨论了如何减少XML配置，利用Java配置和自动装配提高代码的可读性和可维护性。 4. Aspect-oriented Spring：介绍Spring的面向切面编程（AOP）特性，如何创建和使用切面来管理横切关注点。 Part II: Spring application essentials 5. Hitting the Database：涵盖了Spring与数据库的交互，包括JDBC模板、Hibernate和MyBatis等ORM框架的集成。 6. Managing transactions：讲解了Spring的事务管理，如何实现声明式和编程式事务控制。 7. Building web applications with Spring MVC：深入探讨了Spring MVC，用于构建现代Web应用的模型-视图-控制器框架。 8. Spring WebFlow：介绍了Spring WebFlow，一个用于管理复杂用户交互流程的工具。 9. Securing Spring：讨论了Spring Security，用于保护Spring应用的安全框架，包括身份验证和授权策略。 Part III: Integrating Spring 10. Working with remote services：讲解了Spring对远程服务的支持，如RMI、Web服务等。 11. Giving Spring some REST：讨论了如何使用Spring构建RESTful服务，利用Spring MVC和Spring Boot的特性。 12. Messaging in Spring：涵盖了Spring对消息传递系统的支持，包括JMS、AMQP和STOMP等。 13. Managing Spring beans with JMX：介绍了如何使用Java Management Extensions（JMX）来管理和监控Spring Bean。 14. Odds and ends：这部分可能包含了其他杂项内容，如最佳实践、问题解决和Spring框架的最新发展。这本书通过实际示例展示了Spring的强大功能，是学习和掌握Spring框架的宝贵资源，适合开发者、架构师和对Spring感兴趣的技术人员阅读。通过它，读者可以全面了解Spring在不同场景下的应用，并提升其在实际项目中的应用能力。

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 Bin Chen <binchen26@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 Bin Chen <binchen26@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 Bin Chen <binchen26@gmail.com>

剩余479页未读，继续阅读

nancyningxie

粉丝: 0
资源: 1

Spring实战第三版核心特性与整合指南

Spring in Action,ThirdEdition 英文第三版

Csharp.8.Quick.Syntax.Reference.3rd.Edition_2020.pdf

Computer Organization and Design The Hardware Software Interface.3rd.pdf

计算机网络课程设计指导书.pdf

DevelopingWebServicesWithCXFandAxis2ThirdEdition

Spring Action (3rd)

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

Thinking in Java mobi

ContemporaryCommunicationSystemWithMatLabCode.zip

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

最新资源