Spring实践指南：核心概念与依赖注入

需积分: 9 77 浏览量更新于2024-07-23 收藏 1.14MB PDF 举报

"SPRING BY EXAMPLE 是一本介绍Spring框架的书籍，涵盖了Spring的起源、核心概念、依赖注入等关键知识点，并深入讲解了Spring在实际开发中的应用。" 在Spring框架的世界里，"SPRING BY EXAMPLE" 提供了一个全面的指南，帮助读者理解Spring的发展历程和设计哲学。书的前言提到了Spring的进化过程——从智能设计到自然演化的演变，强调了Spring的核心理念。作者希望通过这本书展示Spring如何通过演化而非人为设计来满足不断变化的软件需求。第一章"Spring: Evolution Over Intelligent Design"回顾了Spring的历史，阐述了它从依赖倒置原则发展到依赖注入的过程。依赖倒置是面向对象设计中的一个基本原则，它提倡高层模块不应该依赖于底层模块，两者应该依赖于抽象。而依赖注入（Dependency Injection, DI）作为依赖倒置的实现方式，使得组件之间的耦合度降低，提高了代码的可测试性和可维护性。第二章则介绍了本书的目标，旨在让读者理解Spring的基本概念和工作方式，同时提醒读者注意书中采用的格式和结构。第一部分"Spring Introduction"深入探讨了Spring的核心概念，特别是"Spring in Context: Core Concepts"章节。该章节详细讲解了Spring如何通过控制反转（Inversion of Control, IoC）实现bean管理。IoC意味着应用程序的控制权由外部容器（如Spring框架）负责，而不是由组件自身管理。接着，书中通过实例展示了如何利用IoC进行bean的创建、构造器注入、setter注入以及引用注入，进一步解释了DI的工作原理。此外，书中还提供了创建Spring应用程序的步骤，包括设置环境和创建ApplicationContext，以及如何编写单元测试来验证由ApplicationContext管理的bean。书中的第二部分"Core"将深入到Spring的更多核心功能，如AspectJ的运行时织入（Load-time Weaving），用于实现面向切面编程（AOP）。这部分会涵盖JVM参数配置、Spring配置和AspectJ配置的细节，通过代码示例来展示如何在Spring中集成和使用AspectJ。第三部分"Persistence"将探讨Spring在持久化层的应用，如简单的JDBC模板使用，这将涉及数据库操作的封装和事务管理等概念。 "SPRING BY EXAMPLE"是一本深入浅出的Spring教程，适合初学者和有经验的开发者参考，它不仅教授Spring的基础知识，还提供了实践指导，帮助读者更好地理解和应用Spring框架。

Pree, W. (1994) Meta Patterns – a means for capturing the essentials of reusable object-oriented design. Springer-Verglag, proceedings of the

ECOOP, Bologna, Italy: 150-162

The Dependency Inversion Principle, Martin, Robert C., .c 1994

unmodified by the developer -- and hot spots, the pieces that an application developer contributes

. In Spring, the

hot spots are developer-contributed POJOs which are configured to run within the framework.

In this chapter we'll explore the context of Spring's most important component – the IoC container – and how Spring

can lead you to better Object Oriented programming and eventually to new possibilities with Aspect Oriented

Programming. The Spring framework can't make bad code good, but it can enforce good coding practices that make

it easier for you and your fellow developers to cooperate in writing well-factored, reusable, readable, and

manageable application components.

1. Spring and Inversion of Control

There is a lot of confusion about the definition of the IoC container – some equate it with a design pattern called

Dependency Injection – but in reality IoC is much larger than dependency injection. The Spring IoC container

enforces dependency injection in its various forms and employs a number of established design patterns to achieve

this.

The main idea behind Inversion of Control as a concept is that component dependencies, lifecycle events, and

configuration reside outside of the components themselves, and in the case of Spring, in the framework. This may

sound a bit like giving up too much control, but in fact it can make your code more manageable, more testable, and

more portable.

Before we discuss the Spring IoC container in detail, it's important to understand on the most basic level what the

dependency injection pattern is and how it emerged in object oriented programming methodology. Spring's

Inversion of Control framework is based on some best practice patterns – aspects of Spring IoC resemble and

include the Factory and Observer patterns, and its most prominent feature is its implementation of a framework

which enforces use of the dependency injection pattern.

Dependency Inversion: Precursor to Dependency

Injection

The first reference to what would eventually become Dependency Injection appeared in 1994 in a paper by Robert

C. Martin called “The Dependency Inversion Principle”.

In “The Dependency Inversion Principle” (or DIP), the author states the three defining factors of “bad code”:

1. It is hard to change because every change affects too many other parts of the system (Rigidity)

2. When you make a change, unexpected parts of the system break (Fragility)

3. It is hard to reuse in another application because it cannot be disentangled from the current application

(Immobility)

According to Martin, interdependency causes these coding problems (we'll call them RFI for Rigidity, Fragility, and

Spring In Context: Core Concepts

Spring by Example Version 1.4 Spring by Example 16

Martin Fowler, Inversion of Control Containers and The Dependency Injection Pattern

}

Now the LocalVoteRecorder class – the implementing class of the VoteRecorder interface -- is completely

decoupled from the VotingBooth class. We have removed all hard-coded references to lower level classes.

According to the rules of DIP, this is all we need to do in order to rid our code of RFI.

However, there is one problem with this implementation. We don’t have a main method. We definitely need one in

order to run our application, and somewhere in this main method we will need to instantiate the

LocalVoteRecorder.

By instantiating the LocalVoteRecorder in our main method, we would break Rule #1 of Dependency

Inversion. We have coded to the abstraction, we have integrated our changes, but our application would still have a

dependency on a lower level class.

2. Dependency Injection To The Rescue

Dependency Injection takes the level of decoupling that began with the Dependency Inversion Principle one step

further. Dependency injection has the concept of an assembler

– or what in Java is commonly referred to as a

Factory -- that instantiates the objects required by an application and “injects” them into their dependent objects.

In the case of a dependency injection-informed framework such as Spring, components are coded to interfaces, just

as in the DIP example above. But now the IoC container manages the instantiation, management, and class casting

of the implemented objects so that the application doesn't have to. This removes any true dependencies on low-level

implemented classes.

There are three types of Dependency Injection employed by IoC container providers.

Table 1. Dependency Injection Types

DI Type Description

Constructor Injection The constructor arguments are injected during instance

instantiation.

Setter Injection This is the most favored method of dependency

injection in Spring. Dependencies are “set” in the

objects through setter methods defined in a Spring

configuration file.

Interface Injection This is not implemented in Spring currently, but by

Avalon. It’s a different type of DI that involves

mapping items to inject to specific interfaces.

Spring uses the concept of a BeanFactory as its assembler, and it is the BeanFactory that manages the

JavaBeans you have configured to run within it. In the next section we will discuss Spring's IoC container and how

Spring In Context: Core Concepts

Spring by Example Version 1.4 Spring by Example 19

it makes use of dependency injection patterns to make your code, well, RFI-free, and just better.

3. Bean management through IoC

Through its factory, Spring's IoC container manages the objects that it is configured to instantiate. Spring's

management of the container objects adds flexibility and control to your application, and provides a central place of

configuration management for your Plain Old Java Objects.

For example, through Spring IoC you can configure the number of instances of the component – whether the

component is a singleton or not – and at what point the component is created and destroyed in memory. In Spring,

the initialization of a bean by the framework is exactly equivalent to using the new keyword to instantiate an object

in Java code. Once the framework has instantiated the object, it manages the scope of the bean, based on its

configuration.

Because the IoC container is managing the beans, JNDI lookups that are typical in Java EE containers are no longer

required, leaving your code container-agnostic and easier to unit test both inside and outside of the framework. And

while you are coding to interfaces as part of good OO practice, Spring allows you to manage what implementations

are used by leveraging dependency injection, resulting in cleaner, decoupled components.

The IoC container can also be configured to receive instantiation and destruction callback events for a particular

bean. Certain components such as a database connection pool obviously need to be initialized and destroyed when

the application is shutdown. Instead of using your custom code, Spring can manage these lifecycle events.

4. Our Example In Spring IoC

So how would we configure our simple voting counter example for the Spring IoC container?

We can use our code exactly as is. All we need to do is inform Spring through an XML configuration file that the

recorder bean is implemented by the LocalVoteRecorder class. We do this with the following line:

<bean id="recorder"

class="com.springindepth.LocalVoteRecorder" />

Then we simply map the recorder bean to the VotingBooth bean by setter injection in that beans definition.

<bean id="votingBooth"

class="com.springindepth.VotingBooth">

</bean>

Spring works its magic to handle class instantiation for you, so your application code never becomes aware of the

implementing classes. Now with this configuration and the Spring framework, and through dependency injection,

we have finally removed the low-level component dependencies and have achieved true dependency inversion!

Spring In Context: Core Concepts

Spring by Example Version 1.4 Spring by Example 20

剩余314页未读，继续阅读

downloadsfor

粉丝: 0
资源: 2

Spring实践指南：核心概念与依赖注入

Spring by Example.pdf

春季实例（1.5版）Spring by Example (Version 1.5)

Spring.5.0.By.Example 2018年7月新书 不可不懂得spring5 范例程序

Unknown database 'spring-security-example'

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.example.demo

implements WebMvcConfigurer Spring webmvc4.0.2

spring 中jpa 多条件查询

springboots HikariDataSource

最新资源

Spring.5.0.By.Example 2018年7月新书不可不懂得spring5 范例程序