"Spring by Example.pdf: 丰富的资源和深入探讨"

版权申诉

130 浏览量更新于2024-02-24 收藏 1.14MB PDF 举报

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

30元优惠券

资源详情

资源推荐

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.5 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.5 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.5 Spring by Example 20

剩余314页未读，继续阅读

挖洞的杰瑞

粉丝: 621
资源: 385

"Spring by Example.pdf: 丰富的资源和深入探讨"

Spring.pdf

org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.example.TokenParser' available

Description: Field loginDao in com.example.demo.service.Service required a bean of type 'com.example.demo.dao.LoginDao' that could not be found. The injection point has the following annotations: - @org.springframework.beans.factory.annotation.Autowired(required=true)

spring.cloud.nacos.discovery全部配置及示例

spring.jpa.hibernate.ddl-auto=update 如何指定需要扫描的包

Could not resolve placeholder 'spring.redis.host' in value "${spring.redis.host}"

5116-微信小程序电影院订票选座系统设计及实现+ssm（源码+数据库+lun文）.zip

JavaScript 中的 `Array.prototype.filter` 方法全解析

最新资源