深入理解Spring核心：IoC容器与依赖注入

3星 · 超过75%的资源需积分: 9 23 浏览量更新于2024-07-19 收藏 7.94MB PDF 举报

"Spring官方文档之核心篇，涵盖了Spring框架的核心技术，包括IoC容器、bean的管理和依赖注入等，适合深入学习Spring的开发者参考。" Spring框架是Java开发中的重要组成部分，尤其在企业级应用中广泛应用。这篇文档是Spring框架核心部分的详细指南，版本为5.0.2.RELEASE。以下是文档中涉及的关键知识点： 1. **IoC容器**（Inversion of Control Container）：IoC是Spring的核心特性，它负责管理对象的生命周期和对象间的依赖关系。这使得应用程序代码能够从具体的对象创建和配置中解耦出来。 - **IoC容器概述**：IoC容器通过读取配置元数据来创建和管理bean。配置元数据可以是XML、Java注解或者Groovy DSL。 - **配置元数据**：元数据定义了bean的属性、依赖和其他配置信息。 - **容器实例化**：可以通过XML配置文件或Groovy脚本来实例化容器。 - **使用容器**：容器提供了获取bean实例和管理bean生命周期的方法。 2. **Bean的管理**：Bean是IoC容器中的基本构建块，是Spring管理的对象。 - **命名bean**：bean可以有唯一的名称，也可以通过别名进行引用。 - **bean的实例化**：可以通过构造函数、静态工厂方法或实例工厂方法来创建bean。 3. **依赖注入**（Dependency Injection, DI）：是Spring解决组件之间依赖关系的主要手段，分为构造器注入和setter注入。 - **构造器注入**：通过构造函数传递依赖。 - **setter注入**：通过setter方法设置依赖。 - **依赖解析过程**：容器根据bean的定义自动解析和满足依赖。 - **依赖实例**：包括基本类型、字符串、其他bean引用、内部bean、集合以及空值和空字符串的处理。 4. **XML配置的快捷方式**：Spring提供`p-namespace`和`c-namespace`，简化XML配置中的属性注入。 5. **复合属性名**：允许在XML配置中使用点号分隔的属性路径来注入复杂属性。这些内容构成了Spring框架核心部分的基础，对于理解Spring如何工作以及如何有效地在项目中使用Spring至关重要。通过深入学习和实践，开发者可以掌握Spring的精髓，从而提高代码的可维护性和可扩展性。

ApplicationContext context = new ClassPathXmlApplicationContext("services.xml",

"daos.xml");



After you learn about Spring’s IoC container, you may want to know more about

Spring’s Resource abstraction, as described in Resources, which provides a

convenient mechanism for reading an InputStream from locations defined in a

URI syntax. In particular, Resource paths are used to construct applications

contexts as described in Application contexts and Resource paths.

The following example shows the service layer objects (services.xml) configuration file:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

Ê xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

Ê xsi:schemaLocation="http://www.springframework.org/schema/beans

Ê http://www.springframework.org/schema/beans/spring-beans.xsd">

Ê

Ê <bean id="petStore" class=

"org.springframework.samples.jpetstore.services.PetStoreServiceImpl">

Ê <property name="accountDao" ref="accountDao"/>

Ê <property name="itemDao" ref="itemDao"/>

Ê

Ê </bean>

Ê

</beans>

The following example shows the data access objects daos.xml file:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

Ê xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

Ê xsi:schemaLocation="http://www.springframework.org/schema/beans

Ê http://www.springframework.org/schema/beans/spring-beans.xsd">

Ê <bean id="accountDao"

Ê class="org.springframework.samples.jpetstore.dao.jpa.JpaAccountDao">

Ê

Ê </bean>

Ê <bean id="itemDao" class="

org.springframework.samples.jpetstore.dao.jpa.JpaItemDao">

Ê

Ê </bean>

Ê

</beans>

In the preceding example, the service layer consists of the class PetStoreServiceImpl, and two data

access objects of the type JpaAccountDao and JpaItemDao (based on the JPA Object/Relational mapping

standard). The property name element refers to the name of the JavaBean property, and the ref

element refers to the name of another bean definition. This linkage between id and ref elements

expresses the dependency between collaborating objects. For details of configuring an object’s

dependencies, see Dependencies.

Composing XML-based configuration metadata

It can be useful to have bean definitions span multiple XML files. Often each individual XML

configuration file represents a logical layer or module in your architecture.

You can use the application context constructor to load bean definitions from all these XML

fragments. This constructor takes multiple Resource locations, as was shown in the previous section.

Alternatively, use one or more occurrences of the <import/> element to load bean definitions from

another file or files. For example:

<beans>

Ê <import resource="services.xml"/>

Ê <import resource="resources/messageSource.xml"/>

Ê <import resource="/resources/themeSource.xml"/>

Ê <bean id="bean1" class="..."/>

Ê <bean id="bean2" class="..."/>

</beans>

In the preceding example, external bean definitions are loaded from three files: services.xml,

messageSource.xml, and themeSource.xml. All location paths are relative to the definition file doing

the importing, so services.xml must be in the same directory or classpath location as the file doing

the importing, while messageSource.xml and themeSource.xml must be in a resources location below

the location of the importing file. As you can see, a leading slash is ignored, but given that these

paths are relative, it is better form not to use the slash at all. The contents of the files being

imported, including the top level <beans/> element, must be valid XML bean definitions according

to the Spring Schema.



It is possible, but not recommended, to reference files in parent directories using a

relative "../" path. Doing so creates a dependency on a file that is outside the

current application. In particular, this reference is not recommended for

"classpath:" URLs (for example, "classpath:../services.xml"), where the runtime

resolution process chooses the "nearest" classpath root and then looks into its

parent directory. Classpath configuration changes may lead to the choice of a

different, incorrect directory.

You can always use fully qualified resource locations instead of relative paths: for

example, "file:C:/config/services.xml" or "classpath:/config/services.xml". However,

be aware that you are coupling your application’s configuration to specific

absolute locations. It is generally preferable to keep an indirection for such

absolute locations, for example, through "${…}" placeholders that are resolved

against JVM system properties at runtime.

The import directive is a feature provided by the beans namespace itself. Further configuration

features beyond plain bean definitions are available in a selection of XML namespaces provided by

Spring, e.g. the "context" and the "util" namespace.

The Groovy Bean Definition DSL

As a further example for externalized configuration metadata, bean definitions can also be

expressed in Spring’s Groovy Bean Definition DSL, as known from the Grails framework. Typically,

such configuration will live in a ".groovy" file with a structure as follows:

with XmlBeanDefinitionReader for XML files:

GenericApplicationContext context = new GenericApplicationContext();

new XmlBeanDefinitionReader(context).loadBeanDefinitions("services.xml", "daos.xml");

context.refresh();

Or with GroovyBeanDefinitionReader for Groovy files:

GenericApplicationContext context = new GenericApplicationContext();

new GroovyBeanDefinitionReader(context).loadBeanDefinitions("services.groovy",

"daos.groovy");

context.refresh();

Such reader delegates can be mixed and matched on the same ApplicationContext, reading bean

definitions from diverse configuration sources, if desired.

You can then use getBean to retrieve instances of your beans. The ApplicationContext interface has a

few other methods for retrieving beans, but ideally your application code should never use them.

Indeed, your application code should have no calls to the getBean() method at all, and thus no

dependency on Spring APIs at all. For example, Spring’s integration with web frameworks provides

dependency injection for various web framework components such as controllers and JSF-managed

beans, allowing you to declare a dependency on a specific bean through metadata (e.g. an

autowiring annotation).

1.3. Bean overview

A Spring IoC container manages one or more beans. These beans are created with the configuration

metadata that you supply to the container, for example, in the form of XML <bean/> definitions.

Within the container itself, these bean definitions are represented as BeanDefinition objects, which

contain (among other information) the following metadata:

• A package-qualified class name: typically the actual implementation class of the bean being

defined.

• Bean behavioral configuration elements, which state how the bean should behave in the

container (scope, lifecycle callbacks, and so forth).

• References to other beans that are needed for the bean to do its work; these references are also

called collaborators or dependencies.

• Other configuration settings to set in the newly created object, for example, the number of

connections to use in a bean that manages a connection pool, or the size limit of the pool.

This metadata translates to a set of properties that make up each bean definition.

Table 1. The bean definition

剩余358页未读，继续阅读

Viskbin

粉丝: 2
资源: 5

深入理解Spring核心：IoC容器与依赖注入

Spring框架文档 - 核心技术部分 中文版 - 第一部分.pdf

Spring官方文档

spring boot 官方中文文档.pdf

springSecurity 学习

spring boot 学习资料

spring security教程推荐

springcloud学习思维导图写详细

可以帮我写一段基于Spring MVC的在线商店的代码吗

springboot参考文献

springboot学习教程

最新资源

Spring框架文档 - 核心技术部分中文版 - 第一部分.pdf