java中Spring是什么？

111 Spring是什么

Spring是一个开源的轻量级Java SE（Java 标准版本）/Java EE（Java

企业版本）开发应用框架，其目的是用于简化企业级应用程序开发。应用程序是由一组相互协作的对象组成。而在传统应用程序开发中，一个完整的应用是由一组相互协作的对象组成。所以开发一个应用除了要开发业务逻辑之外，最多的是关注如何使这些对象协作来完成所需功能，而且要低耦合、高内聚。业务逻辑开发是不可避免的，那如果有个框架出来帮我们来创建对象及管理这些对象之间的依赖关系。可能有人说了，比如“抽象工厂、工厂方法设计模式”不也可以帮我们创建对象，“生成器模式”帮我们处理对象间的依赖关系，不也能完成这些功能吗？可是这些又需要我们创建另一些工厂类、生成器类，我们又要而外管理这些类，增加了我们的负担，如果能有种通过配置方式来创建对象，管理对象之间依赖关系，我们不需要通过工厂和生成器来创建及管理对象之间的依赖关系，这样我们是不是减少了许多工作，加速了开发，能节省出很多时间来干其他事。Spring框架刚出来时主要就是来完成这个功能。

Spring框架除了帮我们管理对象及其依赖关系，还提供像通用日志记录、性能统计、安全控制、异常处理等面向切面的能力，还能帮我管理最头疼的数据库事务，本身提供了一套简单的JDBC访问实现，提供与第三方数据访问框架集成（如Hibernate、JPA），与各种Java

EE技术整合（如Java Mail、任务调度等等），提供一套自己的web层框架Spring

MVC、而且还能非常简单的与第三方web框架集成。从这里我们可以认为Spring是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术和框架的能力，从而使我们可以更自由的选择到底使用什么技术进行开发。而且不管是JAVA

SE（C/S架构）应用程序还是JAVA EE（B/S架构）应用程序都可以使用这个平台进行开发。让我们来深入看一下Spring到底能帮我们做些什么？

112 Spring能帮我们做什么

Spring除了不能帮我们写业务逻辑，其余的几乎什么都能帮助我们简化开发：

一、传统程序开发，创建对象及组装对象间依赖关系由我们在程序内部进行控制，这样会加大各个对象间的耦合，如果我们要修改对象间的依赖关系就必须修改源代码，重新编译、部署；而如果采用Spring，则由Spring根据配置文件来进行创建及组装对象间依赖关系，只需要改配置文件即可，无需重新编译。所以，Spring能帮我们根据配置文件创建及组装对象之间的依赖关系。

二、当我们要进行一些日志记录、权限控制、性能统计等时，在传统应用程序当中我们可能在需要的对象或方法中进行，而且比如权限控制、性能统计大部分是重复的，这样代码中就存在大量重复代码，即使有人说我把通用部分提取出来，那必然存在调用还是存在重复，像性能统计我们可能只是在必要时才进行，在诊断完毕后要删除这些代码；还有日志记录，比如记录一些方法访问日志、数据访问日志等等，这些都会渗透到各个要访问方法中；还有权限控制，必须在方法执行开始进行审核，想想这些是多么可怕而且是多么无聊的工作。如果采用Spring，这些日志记录、权限控制、性能统计从业务逻辑中分离出来，通过Spring支持的面向切面编程，在需要这些功能的地方动态添加这些功能，无需渗透到各个需要的方法或对象中；有人可能说了，我们可以使用“代理设计模式”或“包装器设计模式”，你可以使用这些，但还是需要通过编程方式来创建代理对象，还是要耦合这些代理对象，而采用Spring

面向切面编程能提供一种更好的方式来完成上述功能，一般通过配置方式，而且不需要在现有代码中添加任何额外代码，现有代码专注业务逻辑。所以，Spring

面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制。

三、在传统应用程序当中，我们如何来完成数据库事务管理？需要一系列“获取连接，执行SQL，提交或回滚事务，关闭连接”，而且还要保证在最后一定要关闭连接，多么可怕的事情，而且也很无聊；如果采用Spring，我们只需获取连接，执行SQL，其他的都交给Spring来管理了，简单吧。所以，Spring能非常简单的帮我们管理数据库事务。

四、Spring还提供了与第三方数据访问框架（如Hibernate、JPA）无缝集成，而且自己也提供了一套JDBC访问模板，来方便数据库访问。

五、Spring还提供与第三方Web（如Struts、JSF）框架无缝集成，而且自己也提供了一套Spring MVC框架，来方便web层搭建。

六、Spring能方便的与Java EE（如Java Mail、任务调度）整合，与更多技术整合（比如缓存框架）。

Spring能帮我们做这么多事情，提供这么多功能和与那么多主流技术整合，而且是帮我们做了开发中比较头疼和困难的事情，那可能有人会问，难道只有Spring这一个框架，没有其他选择？当然有，比如EJB需要依赖应用服务器、开发效率低、在开发中小型项目是宰鸡拿牛刀，虽然发展到现在EJB比较好用了，但还是比较笨重还需要依赖应用服务器等。那为何需要使用Spring，而不是其他框架呢？让我们接着往下看。

113 为何需要Spring

一 首先阐述几个概念

1、应用程序：是能完成我们所需要功能的成品，比如购物网站、OA系统。

2、框架：是能完成一定功能的半成品，比如我们可以使用框架进行购物网站开发；框架做一部分功能，我们自己做一部分功能，这样应用程序就创建出来了。而且框架规定了你在开发应用程序时的整体架构，提供了一些基础功能，还规定了类和对象的如何创建、如何协作等，从而简化我们开发，让我们专注于业务逻辑开发。

3、非侵入式设计：从框架角度可以这样理解，无需继承框架提供的类，这种设计就可以看作是非侵入式设计，如果继承了这些框架类，就是侵入设计，如果以后想更换框架之前写过的代码几乎无法重用，如果非侵入式设计则之前写过的代码仍然可以继续使用。

4、轻量级及重量级：轻量级是相对于重量级而言的，轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等，其实就是比较容易使用，而重量级正好相反。

5、POJO：POJO（Plain Old Java

Objects）简单的Java对象，它可以包含业务逻辑或持久化逻辑，但不担当任何特殊角色且不继承或不实现任何其它Java框架的类或接口。

6、容器：在日常生活中容器就是一种盛放东西的器具，从程序设计角度看就是装对象的的对象，因为存在放入、拿出等操作，所以容器还要管理对象的生命周期。

7、控制反转：即Inversion of Control，缩写为IoC，控制反转还有一个名字叫做依赖注入（Dependency

Injection），就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。

8、Bean：一般指容器管理对象，在Spring中指Spring IoC容器管理对象。

二

为什么需要Spring及Spring的优点

●

非常轻量级的容器：以集中的、自动化的方式进行应用程序对象创建和装配，负责对象创建和装配，管理对象生命周期，能组合成复杂的应用程序。Spring容器是非侵入式的（不需要依赖任何Spring特定类），而且完全采用POJOs进行开发，使应用程序更容易测试、更容易管理。而且核心JAR包非常小，Spring305不到1M，而且不需要依赖任何应用服务器，可以部署在任何环境（Java

SE或Java EE）。

● AOP：AOP是Aspect Oriented

Programming的缩写，意思是面向切面编程，提供从另一个角度来考虑程序结构以完善面向对象编程（相对于OOP），即可以通过在编译期间、装载期间或运行期间实现在不修改源代码的情况下给程序动态添加功能的一种技术。通俗点说就是把可重用的功能提取出来，然后将这些通用功能在合适的时候织入到应用程序中；比如安全，日记记录，这些都是通用的功能，我们可以把它们提取出来，然后在程序执行的合适地方织入这些代码并执行它们，从而完成需要的功能并复用了这些功能。

●

简单的数据库事务管理：在使用数据库的应用程序当中，自己管理数据库事务是一项很让人头疼的事，而且很容易出现错误，Spring支持可插入的事务管理支持，而且无需JEE环境支持，通过Spring管理事务可以把我们从事务管理中解放出来来专注业务逻辑。

●

JDBC抽象及ORM框架支持：Spring使JDBC更加容易使用；提供DAO（数据访问对象）支持，非常方便集成第三方ORM框架，比如Hibernate等；并且完全支持Spring事务和使用Spring提供的一致的异常体系。

● 灵活的Web层支持：Spring本身提供一套非常强大的MVC框架，而且可以非常容易的与第三方MVC框架集成，比如Struts等。

● 简化各种技术集成：提供对Java Mail、任务调度、JMX、JMS、JNDI、EJB、动态语言、远程访问、Web Service等的集成。

Spring能帮助我们简化应用程序开发，帮助我们创建和组装对象，为我们管理事务，简单的MVC框架，可以把Spring看作是一个超级粘合平台，能把很多技术整合在一起，形成一个整体，使系统结构更优良、性能更出众，从而加速我们程序开发，有如上优点，我们没有理由不考虑使用它。

114 如何学好Spring

要学好Spring，首先要明确Spring是个什么东西，能帮我们做些什么事情，知道了这些然后做个简单的例子，这样就基本知道怎么使用Spring了。Spring核心是IoC容器，所以一定要透彻理解什么是IoC容器，以及如何配置及使用容器，其他所有技术都是基于容器实现的；理解好IoC后，接下来是面向切面编程，首先还是明确概念，基本配置，最后是实现原理，接下来就是数据库事务管理，其实Spring管理事务是通过面向切面编程实现的，所以基础很重要，IoC容器和面向切面编程搞定后，其余都是基于这俩东西的实现，学起来就更加轻松了。要学好Spring不能急，一定要把基础打牢，基础牢固了，这就是磨刀不误砍柴工。

12 Spring基础

121 Spring架构图

图 1-1 Spring架构图

核心容器：包括Core、Beans、Context、EL模块。

●

Core模块：封装了框架依赖的最底层部分，包括资源访问、类型转换及一些常用工具类。

●

Beans模块：提供了框架的基础部分，包括反转控制和依赖注入。其中Bean

Factory是容器核心，本质是“工厂设计模式”的实现，而且无需编程实现“单例设计模式”，单例完全由容器控制，而且提倡面向接口编程，而非面向实现编程；所有应用程序对象及对象间关系由框架管理，从而真正把你从程序逻辑中把维护对象之间的依赖关系提取出来，所有这些依赖关系都由BeanFactory来维护。

● Context模块：以Core和Beans为基础，集成Beans模块功能并添加资源绑定、数据验证、国际化、Java

EE支持、容器生命周期、事件传播等；核心接口是ApplicationContext。

●

EL模块：提供强大的表达式语言支持，支持访问和修改属性值，方法调用，支持访问及修改数组、容器和索引器，命名变量，支持算数和逻辑运算，支持从Spring

容器获取Bean，它也支持列表投影、选择和一般的列表聚合等。

AOP、Aspects模块：

● AOP模块：Spring

AOP模块提供了符合 AOP Alliance规范的面向方面的编程（aspect-oriented

programming）实现，提供比如日志记录、权限控制、性能统计等通用功能和业务逻辑分离的技术，并且能动态的把这些功能添加到需要的代码中；这样各专其职，降低业务逻辑和通用功能的耦合。

● Aspects模块：提供了对AspectJ的集成，AspectJ提供了比Spring ASP更强大的功能。

数据访问/集成模块：该模块包括了JDBC、ORM、OXM、JMS和事务管理。

●

事务模块：该模块用于Spring管理事务，只要是Spring管理对象都能得到Spring管理事务的好处，无需在代码中进行事务控制了，而且支持编程和声明性的事物管理。

●

JDBC模块：提供了一个JBDC的样例模板，使用这些模板能消除传统冗长的JDBC编码还有必须的事务控制，而且能享受到Spring管理事务的好处。

●

ORM模块：提供与流行的“对象-关系”映射框架的无缝集成，包括Hibernate、JPA、Ibatiss等。而且可以使用Spring事务管理，无需额外控制事务。

●

OXM模块：提供了一个对Object/XML映射实现，将java对象映射成XML数据，或者将XML数据映射成java对象，Object/XML映射实现包括JAXB、Castor、XMLBeans和XStream。

● JMS模块：用于JMS(Java Messaging Service)，提供一套

“消息生产者、消息消费者”模板用于更加简单的使用JMS，JMS用于用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

●

Web/Remoting模块：Web/Remoting模块包含了Web、Web-Servlet、Web-Struts、Web-Porlet模块。

● Web模块：提供了基础的web功能。例如多文件上传、集成IoC容器、远程过程访问（RMI、Hessian、Burlap）以及Web

Service支持，并提供一个RestTemplate类来提供方便的Restful services访问。

●

Web-Servlet模块：提供了一个Spring MVC Web框架实现。Spring

MVC框架提供了基于注解的请求资源注入、更简单的数据绑定、数据验证等及一套非常易用的JSP标签，完全无缝与Spring其他技术协作。

●

Web-Struts模块：提供了与Struts无缝集成，Struts1x 和Struts2x都支持

Test模块：

Spring支持Junit和TestNG测试框架，而且还额外提供了一些基于Spring的测试功能，比如在测试Web框架时，模拟Http请求的功能。

122 典型应用场景

Spring可以应用到许多场景，从最简单的标准Java

SE程序到企业级应用程序都能使用Spring来构建。以下介绍几个比较流行的应用场景：

● 典型Web应用程序应用场景：

图1-2 web应用程序应用场景

在Web应用程序应用场景中，典型的三层架构：数据模型层实现域对象；数据访问层实现数据访问；逻辑层实现业务逻辑；web层提供页面展示；所有这些层组件都由Spring进行管理，享受到Spring事务管理、AOP等好处，而且请求唯一入口就是DispachterServlet，它通过把请求映射为相应web层组件来实现相应请求功能。

● 远程访问应用场景：

Spring能非常方便的提供暴露RMI服务，远程访问服务如Hessian、Burlap等，实现非常简单只需通过在Spring中配置相应的地址及需要暴露的服务即可轻松实现，后边会有介绍；

● EJB应用场景：

Spring也可以与EJB轻松集成，后边会详细介绍。

分布式事务是指操作多个数据库之间的事务，在tomcat下是没有分布式事务的，可以借助于第三方Jotm和Automikos实现，下面就写一个使用Jotm实现分布事务的例子，如有不足，请各位大大指点：

Dao及实现，先写出一个interface再去实现他，可能有些人觉得直接写实现类多好，但我还是建议为了结构清晰，增强代码的可读性，可维护性还是先写接口再去实现的好： 

先写一个interface，定义要实现的方法：

实现接口，传入一个String ds来判断调用哪个JdbcTemplate：

service及实现：

还是接口与他的实现：

持久化的操作：

applicationContextxml

基本的spring配置以及Jotm bean;

JTA事务管理器，数据源datasourceA和datasourceB配置:

事务切面配置aop,通知配置以及dao,service配置：

单元测试，在实际项目中就是写一个controller:

你问的好模糊，spring可以进行编程式事务，编程式事务不就是jdbc的6步事务嘛，你spring也可以做jdbc的事务，你扯上mybatis干嘛，你是不是要spring+mybatis整合，问在配置文件中如何配置事务呢

RSocket应用层协议支持 Reactive Streams语义， 例如：用RSocket作为HTTP的一种替代方案。在本教程中， 我们将看到RSocket用在spring boot中，特别是spring boot 如何帮助抽象出更低级别的RSocket API。

让我们从添加spring-boot-starter-rsocket依赖开始：

这个依赖会传递性的拉取RSocket相关的依赖，比如：rsocket-core 和 rsocket-transport-netty

现在继续我们的简单应用程序。为了突出RSocket提供的交互模式，我打算创建一个交易应用程序， 交易应用程序包括客户端和服务器。

31 服务器设置

首先，我们设置由springboot应用程序引导的RSocket server服务器。 因为有spring-boot-starter-rsocket dependency依赖，所以springboot会自动配置RSocket server。 跟平常一样， 可以用属性驱动的方式修改RSocket server默认配置值。例如：通过增加如下配置在applicationproperties中，来修改RSocket端口

也可以根据需要进一步修改服务器的其他属性

32设置客户端

接下来，我们来设置客户端，也是一个springboot应用程序。虽然springboot自动配置大部分RSocket相关的组件，但还要自定义一些对象来完成设置。

这儿我们正在创建RSocket客户端并且配置TCP端口为：7000。注意： 该服务端口我们在前面已经配置过。 接下来我们定义了一个RSocket的装饰器对象RSocketRequester。 这个对象在我们跟RSocket server交互时会为我们提供帮助。 定义这些对象配置后，我们还只是有了一个骨架。在接下来，我们将暴露不同的交互模式， 并看看springboot在这个地方提供帮助的。

我们从Request/Response开始，HTTP也使用这种通信方式，这也是最常见的、最相似的交互模式。 在这种交互模式里， 由客户端初始化通信并发送一个请求。之后，服务器端执行操作并返回一个响应给客户端--这时通信完成。 在我们的交易应用程序里， 一个客户端询问一个给定的股票的当前的市场数据。 作为回复，服务器会传递请求的数据。

41服务器

在服务器这边，我们首先应该创建一个controller 来持有我们的处理器方法。 我们会使用 @MessageMapping注解来代替像SpringMVC中的@RequestMapping或者@GetMapping注解

来研究下我们的控制器。 我们将使用@Controller注解来定义一个控制器来处理进入RSocket的请求。 另外，注解@MessageMapping让我们定义我们感兴趣的路由和如何响应一个请求。 在这个示例中， 服务器监听路由currentMarketData， 并响应一个单一的结果Mono<MarketData>给客户端。

42 客户端

接下来， 我们的RSocket客户端应该询问一只股票的价格并得到一个单一的响应。 为了初始化请求， 我们该使用RSocketRequester类，如下：

注意：在示例中，RSocket客户端也是一个REST风格的controller，以此来访问我们的RSocket服务器。因此，我们使用@RestController和@GetMapping注解来定义我们的请求/响应端点。 在端点方法中， 我们使用的是类RSocketRequester并指定了路由。 事实上，这个是服务器端RSocket所期望的路由，然后我们传递请求数据。最后，当调用retrieveMono()方法时，springboot会帮我们初始化一个请求/响应交互。

接下来我们将查看 Fire And Forget交互模式。正如名字提示的一样，客户端发送一个请求给服务器，但是不期望服务器的返回响应回来。 在我们的交易程序中， 一些客户端会作为数据资源服务，并且推送市场数据给服务器端。

51服务器端

我们来创建另外一个端点在我们的服务器应用程序中，如下：

我们又一次定义了一个新的@MessageMapping路由为collectMarketData。此外， Spring Boot自动转换传入的负载为一个MarketData实例。 但是，这儿最大的不同是我们返回一个Mono<Void>，因为客户端不需要服务器的返回。

52 客户端

来看看我们如何初始化我们的fire-and-forget模式的请求。 我们将创建另外一个REST风格的端点，如下：

这儿我们指定路由和负载将是一个MarketData实例。 由于我们使用send()方法来代替retrieveMono()，所有交互模式变成了fire-and-forget模式。

请求流是一种更复杂的交互模式， 这个模式中客户端发送一个请求，但是在一段时间内从服务器端获取到多个响应。 为了模拟这种交互模式， 客户端会询问给定股票的所有市场数据。

61服务器端

我们从服务器端开始。 我们将添加另外一个消息映射方法，如下：

正如所见， 这个处理器方法跟其他的处理器方法非常类似。 不同的部分是我们返回一个Flux<MarketData>来代替Mono<MarketData>。 最后我们的RSocket服务器会返回多个响应给客户端。

62客户端

在客户端这边， 我们该创建一个端点来初始化请求/响应通信，如下：

我们来研究下RSocket请求。 首先我们定义了路由和请求负载。 然后，我们定义了使用retrieveFlux()调用的响应期望。这部分决定了交互模式。 另外注意：由于我们的客户端也是REST风格的服务器，客户端也定义了响应媒介类型MediaTypeTEXT_EVENT_STREAM_VALUE。

这里我们给异常处理方法标记注解为@MessageExceptionHandler。作为结果， 这个方法将处理所有类型的异常， 因为Exception是所有其他类型的异常的超类。 我们也可以明确地创建更多的不同类型的，不同的异常处理方法。 这当然是请求/响应模式，并且我们返回的是Mono<MarketData>。我们期望这里的响应类型跟我们的交互模式的返回类型相匹配。

第一部分 Spring入门

第1章 Spring简介 2

11 Spring是什么 2

111 依赖注入之外的特性 4

112 使用Spring进行面向方面编程 4

113 数据访问 5

114 简化与整合Java EE 5

115 基于Spring的任务调度 6

116 Spring对邮件的支持 6

117 动态语言 6

118 远程访问 6

119 事务管理 7

1110 Spring MVC框架 7

1111 Spring Web Flow 7

1112 AJAX技术 7

1113 国际化 8

1114 简化异常处理 8

12 Spring项目 8

121 Spring的起源 8

122 Spring NET 8

123 Spring IDE 9

124 Spring安全系统（原Acegi） 9

125 Spring的替代方案 9

13 示例代码 10

14 小结 10

第2章 Spring入门 11

21 获取Spring框架 11

211 从CVS上签出Spring 11

212 从源码构建Spring 12

213 检查Spring发布包 13

214 Spring发布包 13

215 Spring依赖的包 14

216 示例应用 16

217 配置Spring和IDE 18

22 HelloWorld示例 20

23 Spring版本的“Hello, World”示例 23

231 依赖注入 24

232 Spring的侵入性 26

24 小结 26

第3章 控制反转 27

31 控制反转和依赖注入 27

32 控制反转的类型 27

321 上下文依赖查找 29

322 构造方法依赖注入 30

323 设置方法依赖注入 31

324 依赖注入与依赖查找 32

325 设置方法注入与构造方法注入 33

33 Spring中的控制反转 34

34 基于Spring的依赖注入 34

341 bean和BeanFactory 34

342 BeanFactory实现 35

343 XML bean定义 36

344 构造方法注入 37

345 注入参数 40

346 理解bean的命名 50

347 bean的实例化模式 52

348 解析依赖 55

349 bean的自动装配 57

3410 依赖检查 61

3411 bean的继承 62

35 小结 64

第4章 进阶 66

41 Spring对应用程序可移植性的影响 67

42 管理bean的生命周期 67

421 嵌入bean的创建 68

422 嵌入bean的销毁 74

43 让bean可被Spring感知 79

431 使用BeanNameAware接口 80

432 使用BeanFactoryAware接口 81

44 使用方法注入（method injection） 83

441 查找方法注入 83

442 方法替换 88

45 使用FactoryBean接口 91

451 MessageDigestFactoryBean类 91

452 直接访问FactoryBean 94

46 BeanFactoryPostProcessor类 94

47 JavaBean的属性修改器 101

471 内建的PropertyEditor 101

472 创建自定义PropertyEditor 104

48 BeanPostProcessor类 108

481 实现一个BeanPostProcessor 110

482 使用BeanPostProcessor类的实机选择 114

49 Spring ApplicationContext 115

491 ApplicationContext的实现类 115

492 使用ApplicationContext-Aware 116

493 控制bean的初始化 117

494 使用基于注解的配置 118

495 使用MessageSource进行国际化 123

496 在独立应用中使用MessageSource 130

497 MessageSourceResolvable接口 130

498 使用应用程序事件 130

499 对于事件用法的考虑 132

4910 访问资源 133

410 小结 134

第5章 Spring AOP基础 135

51 AOP概念 136

52 AOP的类型 136

521 静态AOP 137

522 动态AOP 137

523 选择一种AOP类型 137

53 Spring中的AOP 137

531 AOP联盟 138

532 AOP的Hello World 138

533 Spring AOP架构 140

534 ProxyFactory类 140

535 在Spring中创建通知 141

54 Spring里的通知者和切入点 155

541 切入点接口 156

542 使用ComposablePointcut 172

543 切入点总结 175

55 代理详解 176

551 理解代理 176

552 使用JDK动态代理 176

553 使用CGLIB代理 177

554 两者的性能比较 177

555 选用代理 180

56 小结 180

第6章 AOP进阶 182

61 @AspectJ注解 182

62 @AspectJ方面详解 186

621 切入点 186

622 切入点表达式 189

623 探讨切入点表达式 191

624 在XML中使用@Pointcuts 194

625 通知的类型 194

626 参数绑定 201

627 引入 202

628 方面的生命周期 208

63 AOP的框架服务 209

631 使用AOP命名空间创建第一个方面 209

632 AOP命名空间中的切入点 211

633 使用AOP命名空间创建通知 212

634 AOP命名空间中的引入 217

64 风格选择 219

65 使用Spring AOP代理 220

66 AspectJ集成 225

661 创建第一个AspectJ方面 225

662 编译示例程序 227

663 AspectJ方面的作用域 229

67 加载时织入 230

671 第一个加载时织入示例 230

672 LoadTimeWeaver的查找策略 232

68 AOP实践 232

69 小结 235

第7章 Spring schema与命名空间 236

71 新配置的缘由 236

72 Spring 25包含的schema 238

721 beans schema 238

722 上下文schema 239

723 util schema 239

724 tx schema 242

725 aop schema 242

726 jee schema 242

727 lang schema 243

73 schema背后 244

74 自定义schema 246

75 IDE配置 249

76 小结 252

第8章 Spring模式 253

81 目录结构 253

811 简单应用 253

812 复杂应用 255

813 打包和命名 255

82 设计模式简介 255

821 面向接口编程 256

822 创建模式 256

823 结构模式 260

824 行为模式 262

83 Spring应用模式 264

831 分层设计 265

832 高性能分页 266

833 多错误报告 268

834 用户界面事务 271

835 后台进程 274

836 邮件通知 278

837 错误收集和日志 280

84 小结 283

第二部分 数据访问

第9章 Spring对JDBC的支持 286

91 JDBC的主要概念 286

911 使用DriverManager和Connection 288

912 使用PreparedStatement 289

913 使用CallableStatement类 292

914 其他JDBC概念 293

92 Spring对数据访问支持的概念 293

93 Spring对JDBC数据访问的支持 294

94 使用JdbcTemplate类 294

941 JdbcTemplate类的execute方法 296

942 JdbcTemplate类的query方法和该方法的扩展 299

943 JdbcTemplat类的update方法 303

944 JdbcTemplate类的batchUpdate方法 304

95 RdbmsOperation子类 305

951 SqlUpdate子类 306

952 BatchSqlUpdate子类 311

953 SqlCall类和StoredProcedure子类 312

954 SqlQuery类和它的子类 314

955 JdbcTemplate类和RdbmsOperation类的比较 321

96 大二进制对象 321

97 JdbcDaoSupport类 324

98 简单的Spring JDBC 326

981 SimpleJdbcTemplate类 326

982 SimpleJdbcCall类 329

983 SimpleJdbcInsert类 331

984 SimpleJdbcDaoSupport类 332

99 小结 333

第10章 集成iBATIS 334

101 iBATIS简述 334

1011 iBATIS版本 334

1012 基础架构和配置 335

102 映射文件 335

1021 sqlMap文件 337

1022 配置iBATIS和Spring 339

103 查询数据 341

1031 简单查询操作 341

1032 一对一查询操作 344

1033 一对多查询操作 348

1034 多对多查询操作 350

104 更新数据 350

105 删除数据 353

106 插入数据 354

107 iBATIS缺少的特性 356

108 整体性能 357

109 小结 358

第11章 Spring对Hibernate的支持 359

111 Hibernate入门 359

112 Hibernate打包 360

113 Hibernate支持的介绍 361

1131 使用Hibernate Session 363

1132 使用HibernateDaoSupport类 366

1133 HibernateTemplate和Session间的选择 368

114 在企业级应用程序中使用Hibernate 372

1141 阻止更新脏数据 372

1142 对象等价性 375

1143 事务支持 378

1144 延迟加载 382

115 处理大数据集 392

116 处理大对象 394

117 使用Hibernate处理其他DAO代码 397

118 小结 398

第三部分 企业级应用组件

第12章 基于Spring的任务调度 400

121 使用JDK Timer调度任务 401

1211 Timer触发器类型 401

1212 创建一个简单任务 401

1213 Spring对JDK Timer调度的支持 404

122 使用OpenSymphony Quartz来调度任务 409

1221 Quartz简介 410

1222 Spring对Quartz的支持 418

123 任务调度时需考虑的因素 423

1231 选择一个调度器 423

1232 剥离Job类中的任务逻辑 424

1233 任务执行和线程池 424

124 小结 428

第13章 Spring的邮件支持 429

131 Spring Mail API结构 430

132 发送简单的电子邮件 430

1321 编程式构造和发送电子邮件 431

1322 声明式构造电子邮件 433

133 构造并发送MIME消息 436

1331 发送基本的HTML消息 438

1332 发送带有内嵌的HTML消息 439

1333 发送带有附件的消息 441

1334 发送带有可替换纯文本的HTML消息 442

1335 发送复杂MIME消息 445

134 深入了解企业级电子邮件处理 449

135 小结 458

第14章 动态语言 459

141 支持的动态语言概览 459

1411 BeanShell 459

1412 Groovy 461

1413 JRuby 462

142 使用动态语言定义Spring bean 463

1421 动态语言支持的幕后 465

1422 代理动态语言bean 466

1423 性能 466

143 可刷新bean（refreshable bean） 468

144 基于BeanShell的bean 470

145 基于JRuby的bean 472

146 基于Groovy的bean 473

147 动态语言在Spring程序中的典型应用 473

148 小结 477

第四部分 Java EE 5应用开发

第15章 Spring远程访问 480

151 Spring Remoting架构 481

152 远程方法调用 482

1521 开放任意的服务 482

1522 通过代理访问RMI服务 484

1523 开放CORBA服务 486

1524 访问CORBA服务 488

153 使用JAX-RPC实现Web服务 490

1531 Apache Axis简介 490

1532 使用ServletEndpoint- Support创建Web服务 490

1533 使用代理访问RPC风格的Web服务 494

1534 与Axis服务的JavaBean交互 497

154 使用JAX-WS Web服务 500

1541 通过SimpleJaxWsService-Exporter公开Web服务 501

1542 使用XFire公开Web服务 501

1543 访问JAX-WS Web服务 503

1544 从其他客户端访问Java Web服务 504

155 使用HTTP Invoker创建Web服务 507

1551 开发简单服务 508

1552 通过代理访问HTTP Invoker服务 510

1553 在HTTP Invoker服务中使用任意对象 511

1554 使用HTTP基本认证 513

156 远程架构的选择 516

157 小结 517

第16章 事务管理 518

161 Spring事务抽象层简介 518

162 分析事务属性 519

1621 探索TransactionDefinition接口 519

1622 使用TransactionStatus接口 520

1623 PlatformTransactionManager的实现 521

163 对一个事务管理示例的探索 521

164 编程式事务管理 529

1641 使用TransactionTemplate类 531

1642 编程式事务管理小结 532

165 声明性事务管理 532

1651 使用TransactionProxy-FactoryBean 532

1652 在事务管理中使用代理的含义 534

166 AOP事务管理 535

1661 使用基于注解的AOP事务管理 535

1662 使用XML AOP事务管理 537

1663 tx:advice标签简介 538

1664 XML AOP小结 539

167 在多个事务性资源上使用事务 540

168 实现你自己的事务同步 541

169 小结 548

第17章 基于Spring MVC的Web应用开发 549

171 MVC架构 549

172 Spring MVC介绍 550

173 使用处理器映射 551

174 Spring控制器 553

1741 AbstractController类 554

1742 ParameterizableView-Controller类 555

1743 MultiActionController类 555

175 拦截器 558

176 视图、本地化和主题 559

1761 以编程的方式使用视图 559

1762 使用视图解析器 561

1763 使用本地化消息 565

1764 使用Locale 565

1765 使用主题 565

177 命令控制器 567

1771 使用表单控制器 568

1772 探索AbstractWizardForm- Controller 类 574

1773 文件上传 578

178 处理异常 581

179 Spring与其他Web技术 583

1791 使用JSP 583

1792 使用Velocity 600

1793 FreeMarker 604

1794 使用XSLT视图 608

1795 使用PDF视图 609

1796 实现PDF视图 610

1797 使用Excel视图 611

1798 使用Tiles 613

1799 JasperReports报表引擎 623

1710 Spring的约定优于配置 627

17101 控制器约定 628

17102 MultiActionController约定 628

17103 模型约定 629

17104 视图约定 630

1711 使用注解配置控制器 631

17111 @Controller注解 631

17112 @RequestMapping注解 632

17113 @RequestParam注解 633

17114 @ModelAttribute注解 633

17115 使用注解配置命令控制器 634

1712 小结 635

第18章 Spring Web Flow 636

181 Spring Web Flow简介 637

1811 核心概念 637

1812 获取Spring Web Flow 640

1813 Spring Web Flow依赖 642

182 Hello, Web Flow! 642

183 探索状态 646

1831 view状态 647

1832 decision状态 647

1833 end状态 648

184 处理转换 648

185 高级概念 650

1851 表达式语言和范围 650

1852 实现action 653

1853 模型数据绑定 654

1854 局部视图刷新 658

1855 映射流的输入与输出参数 658

1856 使用子流 659

186 幕后的Spring Web Flow 660

1861 流执行架构 660

1862 流执行者 662

1863 流定义注册表 662

1864 流执行仓库 665

187 集成Spring MVC 666

1871 流处理 666

1872 视图解析 667

188 使用Spring Security构建安全的流 668

1881 第一步：添加SecurityFlow- ExecutionListener 668

1882 第二步：处理基本的认证和授权 668

1883 第三步：在流定义中定义安全规则 670

189 问题解决 672

1891 带状态的导航控制 672

1892 浏览器导航栏支持和双提交（double submit） 672

1810 测试流定义 673

1811 小结 674

第19章 Spring与AJAX 675

191 DWR 675

192 安装DWR 676

193 针对DWR的Spring配置 676

194 关于完整示例 677

195 测试DWR配置 682

196 运行完整示例 682

197 DWR脚本基础 683

1971 使用简单的回调函数 683

1972 调用元数据对象 684

198 enginejs文件 684

1981 调用批处理 684

1982 调用顺序 684

1983 错误和警告处理 684

199 utiljs脚本 685

1910 DWR的安全性 685

1911 DWR的优缺点 686

1912 小结 687

第20章 使用Spring JMX 688

201 JMX进阶 688

202 开放Java Bean 689

2021 MBeanExporter类 689

2022 MBeanServer FactoryBean类 691

2023 在已有的MBean服务器上开放Bean 692

2024 Bean注册行为 692

203 控制对象名 693

204 控制管理接口 693

2041 MBeanInfoAssembler接口 693

2042 MethodNameBasedMBean-InfoAssembler接口 694

2043 用Java接口来控制管理接口 696

2044 使用源码级元数据 698

205 远程使用Spring JMX 701

2051 开放远程MBean 701

2052 访问远程MBean 702

2053 代理MBean 702

206 Spring JMX通知 703

2061 通知监听器 703

2062 发布通知 704

207 小结 708

第21章 使用Spring进行测试 709

211 进行单元测试 709

212 单元测试 711

213 集成测试 715

2131 使用AbstractSpring- ContextTests 722

2132 使用AbstractDependency- InjectionSpringContext-Tests类 723

2133 使用AbstractTransac-tionalSpringContextTest 726

2134 使用AbstractAnnotation-AwareTransactionalTest 728

2135 JNDI 731

214 Spring TestContext Framework 733

2141 应用上下文及使用TestContext Framework进行依赖注入 733

2142 使用TestContext Framework进行依赖注入 735

2143 TestContext Framework中的事务 736

2144 支持类 738

215 测试覆盖 740

216 小结 740

第22章 Spring性能调优 741

221 性能与响应 741

222 探索企业应用的性能问题 741

223 测量Java EE应用的性能 742

2231 测量目标 742

2232 确定必要的数据集 747

2233 改善数据访问层 748

2234 提高事务管理 757

2235 控制远程调用的性能 758

2236 了解视图性能 758

224 使用缓存 759

225 性能测试 760

226 监控应用程序的状态和性能 762

227 更多的性能调优资源 764

228 小结 764