Spring框架官方参考文档2.5.4版：IoC容器与AOP新特性

下载需积分: 0 | PDF格式 | 4.2MB | 更新于2024-08-02 | 97 浏览量 | 举报

"Spring官方参考文档，详细介绍了如何将Spring与Axis集成，涵盖了Spring框架的2.5.4版本的主要特性，包括IoC容器、AOP编程等方面的更新内容。" 在Spring Framework的官方参考文档中，我们可以深入理解Spring的核心概念和技术。这份文档是基于版本2.5.4编写的，该版本引入了许多重要的改进和新特性，旨在提升开发效率和应用的灵活性。 1. **Introduction** - 部分概述了Spring框架的基本理念和设计目标。它强调了Spring如何通过Inversion of Control (IoC)和Aspect-Oriented Programming (AOP)来简化企业级Java应用的开发。文档还描述了Spring框架在实际应用场景中的各种用例，包括数据访问、事务管理、Web应用集成等。 2. **What's new in Spring 2.0 and 2.5?** - 这部分详细列出了Spring 2.0和2.5版本的主要更新内容： - **IoC容器**：2.5版本引入了新的bean作用域，如prototype和session，使开发者能更灵活地管理bean的生命周期。此外，XML配置变得更加简洁，允许使用更多内联元素。XML作者化也得到了扩展，支持了更高级的配置方式。 - **Annotation-driven configuration**：Spring 2.5引入了注解驱动的配置，开发者可以直接在类或方法上使用注解来声明依赖注入，减少了XML配置的需求。 - **自动组件检测**：框架现在可以自动检测类路径中的组件，进一步简化了配置工作。 - **AOP增强**：AOP配置变得更加简单，同时支持了@AspectJ注解驱动的切面。这使得编写和使用切面更加直观，无需额外的XML配置。此外，还增加了对bea的AOP支持。 3. **Aspect Oriented Programming (AOP)** - AOP部分详细介绍了Spring如何提供面向切面的编程能力，包括切面的定义、通知（advice）类型和目标对象的织入（weaving）。AOP在处理横切关注点（如日志、事务管理）时特别有用，它允许这些功能与核心业务逻辑分离。这份文档是学习和理解Spring框架的重要资源，特别是对于那些希望将Spring与Axis服务集成的开发者来说。它不仅包含了基本概念的介绍，还提供了详细的API参考和示例，有助于开发者深入实践并掌握Spring的强大功能。

Chapter 1. Introduction

Background

In early 2004, Martin Fowler asked the readers of his site: when talking about Inversion of Control: “the

question is, what aspect of control are [they] inverting?”. Fowler then suggested renaming the principle

(or at least giving it a more self-explanatory name), and started to use the term Dependency Injection. His

article then continued to explain the ideas underpinning the Inversion of Control (IoC) and Dependency

Injection (DI) principle.

If you need a decent insight into IoC and DI, please do refer to said article :

http://martinfowler.com/articles/injection.html.

Java applications (a loose term which runs the gamut from constrained applets to full-fledged n-tier server-side

enterprise applications) typically are composed of a number of objects that collaborate with one another to form

the application proper. The objects in an application can thus be said to have dependencies between themselves.

The Java language and platform provides a wealth of functionality for architecting and building applications,

ranging all the way from the very basic building blocks of primitive types and classes (and the means to define

new classes), to rich full-featured application servers and web frameworks. One area that is decidedly

conspicuous by its absence is any means of taking the basic building blocks and composing them into a

coherent whole; this area has typically been left to the purvey of the architects and developers tasked with

building an application (or applications). Now to be fair, there are a number of design patterns devoted to the

business of composing the various classes and object instances that makeup an all-singing, all-dancing

application. Design patterns such as Factory, Abstract Factory, Builder, Decorator, and Service Locator (to

name but a few) have widespread recognition and acceptance within the software development industry

(presumably that is why these patterns have been formalized as patterns in the first place). This is all very well,

but these patterns are just that: best practices given a name, typically together with a description of what the

pattern does, where the pattern is typically best applied, the problems that the application of the pattern

addresses, and so forth. Notice that the last paragraph used the phrase “... a description of what the pattern

does...”; pattern books and wikis are typically listings of such formalized best practice that you can certainly

take away, mull over, and then implement yourself in your application.

The IoC component of the Spring Framework addresses the enterprise concern of taking the classes, objects,

and services that are to compose an application, by providing a formalized means of composing these various

disparate components into a fully working application ready for use. The Spring Framework takes best

practices that have been proven over the years in numerous applications and formalized as design patterns, and

actually codifies these patterns as first class objects that you as an architect and developer can take away and

integrate into your own application(s). This is a Very Good Thing Indeed as attested to by the numerous

organizations and institutions that have used the Spring Framework to engineer robust, maintainable

applications.

1.1. Overview

The Spring Framework contains a lot of features, which are well-organized in six modules shown in the

diagram below. This chapter discusses each of the modules in turn.

Spring Framework (2.5.4) 16

The Core package is the most fundamental part of the framework and provides the IoC and Dependency

Injection features. The basic concept here is the BeanFactory, which provides a sophisticated implementation

of the factory pattern which removes the need for programmatic singletons and allows you to decouple the

configuration and specification of dependencies from your actual program logic.

The Context package build on the solid base provided by the Core package: it provides a way to access objects

in a framework-style manner in a fashion somewhat reminiscent of a JNDI-registry. The context package

inherits its features from the beans package and adds support for internationalization (I18N) (using for example

resource bundles), event-propagation, resource-loading, and the transparent creation of contexts by, for

example, a servlet container.

The DAO package provides a JDBC-abstraction layer that removes the need to do tedious JDBC coding and

parsing of database-vendor specific error codes. Also, the JDBC package provides a way to do programmatic as

well as declarative transaction management, not only for classes implementing special interfaces, but for all

your POJOs (plain old Java objects).

The ORM package provides integration layers for popular object-relational mapping APIs, including JPA, JDO,

Hibernate, and iBatis. Using the ORM package you can use all those O/R-mappers in combination with all the

other features Spring offers, such as the simple declarative transaction management feature mentioned

previously.

Spring's AOP package provides an AOP Alliance-compliant aspect-oriented programming implementation

allowing you to define, for example, method-interceptors and pointcuts to cleanly decouple code implementing

functionality that should logically speaking be separated. Using source-level metadata functionality you can

also incorporate all kinds of behavioral information into your code, in a manner similar to that of .NET

attributes.

Spring's Web package provides basic web-oriented integration features, such as multipart file-upload

functionality, the initialization of the IoC container using servlet listeners and a web-oriented application

context. When using Spring together with WebWork or Struts, this is the package to integrate with.

Spring's MVC package provides a Model-View-Controller (MVC) implementation for web-applications.

Spring's MVC framework is not just any old implementation; it provides a clean separation between domain

model code and web forms, and allows you to use all the other features of the Spring Framework.

1.2. Usage scenarios

With the building blocks described above you can use Spring in all sorts of scenarios, from applets up to

fully-fledged enterprise applications using Spring's transaction management functionality and web framework

integration.

Introduction

Spring Framework (2.5.4) 18

剩余586页未读，继续阅读

qinjuanmeng

粉丝: 0
资源: 1

Spring框架官方参考文档2.5.4版：IoC容器与AOP新特性

Spring文档：Spring-Reference_2.5_zh_CN.chm、Spring-Reference_2.5_zh_CN.chm

spring-reference1.1.pdf

spring-reference1.1(中文版)

spring-boot-starter与spring-boot-starter-web

spring-boot-starter-parent3.1.2与spring-context

spring-boot-admin-starter-server如何获取spring-boot-admin-starter-client自定义的属性

spring-cloud-dependencies 和 spring-cloud-dependencies-parent的区别

springboot 项目parent里面写spring-boot-starter-parent和spring-boot-parent有什么区别

spring-boot-starter-web和starter

spring-boot-starter-web高版本

最新资源