Spring个人总结

编写Spring第一个程序

Spring是一种开源框架，通过使用它可以大大降低企业应用程序的复杂性。Spring是一种非常完善的框架，几乎涉及WEB开发中的每一层，但是在开发中通常使用Spring开发业务逻辑层，资深的Java EE开发人员会发现Spring框架似曾相识，它其实没有太多的新东西，只是抽象了大量Java EE应用中常用代码，将他们抽象成一个框架，框架中充满了各种设计模式的应用，如单例模式、工厂模式、抽象工厂模式、命令模式、职责链模式、代理模式等，通过使用Spring可以大幅度提高开发效率，课可以保证整个应用具有良好的设计。Spring像是一种中间容器，向上可以与MVC框架无缝整合，向下可以与各种持久层框架无缝整合。

重点内容：

了解Spring架构和为什么使用Spring

下载和安装Spring

在集成开发工具中使用Spring

开发Spring的第一个程序

Spring概述

1.为什么使用Spring

Spring是一种轻量级框架，轻量级是指该框架技术是非入侵式的，用Spring中开发的系统类不需要依赖于Spring中的类，它不需要容器支持。

在没使用Spring之前，如果在业务逻辑层中访问数据访问层，需要在业务逻辑层中创建数据访问层的对象，然后使用该对象调用DAO方法。

使用这种方式使业务逻辑层和数据访问层的耦合性非常高，当数据访问层程序发生改动时，则还需要来改动业务访问层的程序，这样就增加了程序员的工作量。

当Spring出现以后，这种问题就得到了很好的解决。业务逻辑层和数据访问层之间是注入的关系，在业务逻辑层中并不需要创建数据访问层的对象。

2.Spring技术介绍

Spring是一种非常完整的技术，也就是说只使用Spring技术也能开发项目。但是在实际开发中并不这样做，只是让Spring做业务逻辑层，因为Spring的业务处理能力是非常强大的。

在Spring技术中，最经典的就是IoC和AOP技术。其中IoC是指依赖注入，通过使用该技术可以使业务逻辑层和数据访问层解耦合。

Spring的另一个重要技术那就是AOP，通过使用AOP可以很容易的完成切面开发。在后面的学习中将最这两个重要技术进行详细讲解。

Spring开发环境的搭建

1.手动搭建

手动搭建Spring开发环境需要两步，分别是下载和安装。下载Spring可以通过Spring官方网站的下载频道进行下载，下载地址为“http://repo.spring.io/release/org/springframework/spring/”，在其中选择下载Spring Framework。下载后是一个zip文件，将其解压，可以看到在它下面有很多目录。

其中libs是Spring的核心目录，在其中保存了Spring开发生成的JAR文件。docs是帮助目录，其中包含了Spring教程和API文档。

1.手动搭建

Spring的优点就是不依赖于任何服务器和框架，安装Spring时只需要将提供的JAR文件设置到CLASSPATH中。在Spring框架中有很多中JAR文件，它对应着Spring的各种应用。在Spring的研发中，也为初学者考虑到，创建了一个spring-core-版本.jar包，它位于libs目录下，在该包中Spring基本使用类。除了要使用该包外，还要使用到commons-logging.jar包，下载地址：http://commons.apache.org/proper/commons-logging/。

如果使用Spring进行WEB开发，其安装是更简单的，只需要将这两个包复制到WEB应用的WEB-INF\lib目录下。

2.使用Eclipse自动搭建

在Eclipse中集成了Spring项目开发，通过它是非常容易的搭建Spring开发环境的，它的步骤如下：

（1）选中要进行Spring开发的项目，右击选择Build Path，Configure Build Path...，将需要的架包加入项目中，如下：

开发Spring的HelloWorld程序

1.开发Spring程序的步骤

Spring的主要功能是对业务逻辑层进行操作，为了简单需要，在该第一个程序中，采用Java项目的方式进行开发，在其中只给出业务逻辑层。

Spring开发是有严格的步骤的，无论项目简单和复杂，都要按照这个步骤进行操作。在开发业务逻辑层时，一定要定义业务接口和业务实现类，这是Spring开发的第一步。然后在Spring配置文件中对业务实现类进行配置。最后是开发客户端程序，进行项目测试。

2.编写业务接口

先来开发业务接口，在该业务接口中定义了SayHello方法。通过该方法创建一个接收姓名信息，然后返回问候语句功能。

package com.tufujie.service;
public interface HelloService {
public String SayHello(String name);
}

3.编写业务实现类

开发完业务接口后，就继续来编写业务实现类。业务实现类要实现业务接口，从而实现业务接口中的抽象方法。

public class HeloServiceImpl implements HelloService {
public String SayHello(String name) { return "Hello！！！"+name;
}
}

4.配置业务实现类

配置业务实现类，需要在项目的src目录下创建一个Spring的配置文件，该文件的名称是可以灵活改变的，通常命名为applicationContext.xml。

<?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-2.0.xsd">
<bean id="hello" class="com.tufujie.service.HeloServiceImpl">
</bean>
</beans>

5.编写客户端进行测试

到目前为止，Spring的程序已经开发完毕，在本小节中就通过一个客户端程序来对Spring的程序进行测试。通过该客户端程序调用业务实现类中的业务方法。

public static void main(String[] args) {
BeanFactory factory = new ClassPathXmlAppl
icationContext("applicationContext.xml")
HelloService helloService=(HelloService)
factory.getBean("hello");
String name="Tom";
System.out.println(helloService.SayHello(name));
}

控制反转

控制反转是Spring的核心技术之一，它是英文名称为“Inversion of Control”，所以在很多地方将控制反转缩写为IoC。Spring的很多功能都是基于控制反转技术的。在上一章中学习Spring的第一个程序时，就是一个简单的IoC程序。在本章中将继续学习Spring的这一核心技术。

重点内容：

Spring容器和容器中的Bean

掌握各种依赖注入

Bean特性介绍

ApplicationContext的使用

IoC容器

1.Bean工厂接口

Bean工厂接口在前面的学习中已经见到过，它的全称接口名为“org.springframework.beans.factory.BeanFactory”，该接口程序可以在Spring的核心JAR包spring.jar中找到。在Spring程序中，BeanFactory实际上是IoC的代表者，通过使用该接口对其中的Bean进行管理。

在Spring中，定义了多种Bean工厂接口的实现类，它们的使用是有很大不同的。其中比较常用的就是XmlBeanFactory，使用该类可以XML文件的形式来描述对象和对象之间的关系。在学习第一个Spring程序时，就是以XML文件的形式对业务实现类对象进行配置的。

2.实例化容器

要想使用IoC容器，就需要对容器进行实例化操作，通过实例化后的容器对象就可以访问其中的Bean对象。当使用XML配置文件的方式对Bean对象进行管理时，实例化容器的过程其实也是加载配置文件的过程。实体化容器其实也是加载配置文件的过程实例化容器有多种方式，在本节中就来对这些方式进行一一讲解。

首先来看第一种通过系统路径进行实例化的方式，该方式是和IO流操作非常相似的，在其中使用FileSystemResource类构造函数来指定配置文件的位置。第二种方式是通过ClassPath查找配置文件，该方法的前提是配置文件必须在ClassPath环境配置中。第三种方式是通过上下文实例化，这里要使用到BeanFactory接口的子接口Application Context。

3.多配置文件的使用

当开发的项目很大时，使用一个Spring配置文件是比较复杂的，其中可能具有几千行的配置信息，在其中查找某一个Bean对象的配置是非常困难的。所以在Spring中可以定义多个配置文件，将一类配置放置在一个文件中。

当一个项目中具有多个Spring配置文件时，就会出现一个问题，那就是该如何实例化容器。在Spring中，设计了两种方式。一种是使用ApplicationContext实现类的重载构造函数，将所有配置文件的路径组成字符串数据做为参数，例如：

ApplicationContext context =new  ClassPathXmlApplicationContext(new String[]{ "applicationContext.xml","applicationContext-part2.xml"});
BeanFactory factory = context;

4.配置Bean

在学习第一个程序后，已经见过了如何配置Bean。配置Bean是通过使用<bean>标记对其进行配置，其中class属性指定Bean的完整路径。每一个Bean中都有一个或者多个id属性，id是Bean的标识符，在当前IoC容器中必须是唯一的。如果一个Bean有多个id，则将其他id在本质上被认为是别名。

为Bean指定别名在特定环境下是非常必要的，例如我们指定操作老师的DAO的名称为“teacherDAO”，但是在对学生操作时也会使用到该DAO，这时候就可以为它起一个别名为“studentDAO”进行使用。定义别名除了定义多个id属性外，还可以在Bean定义后补充，这里要使用到<alias>标记。例如完成如上功能的代码为：

<alias name=" teacherDAO" alias=" studentDAO "/>

5.使用容器实例化Bean

对容器实例化后，使用容器对象调用getBean方法，在其中使用id属性值做为参数，就可以实例化指定的Bean。例如：

HelloServicehelloService = (HelloService)factory.getBean("hello");

这里使用到了根据Java的反射机制创建一个实际的对象。可以看到我们使用容器实例化Bean是非常简单的，但是在Spring的内部操作是比较复杂的。在Spring中，实例化Bean有三种方式，分别是使用构造器、使用静态工厂方法和使用实例工厂方法。

6.容器常用方法

BeanFactory容器中除了getBean方法中外，还有其他几种常用的方法，这里我们对这些方法进行简单的介绍。

boolean containsBean(String)
Object getBean(String, Class)
Class getType(String name)
boolean isSingleton(String)
String[] getAliases(String)

依赖注入

1.Setter方法注入

使用Setter方法进行注入是依赖注入的一种方式。在使用Bean中，定义需要注入属性的Setter方法，然后在Spring配置文件中给出该属性的值，最后在客户端程序中就可以访问这些属性值。先来看一个Bean程序。

<bean id="student" class="com.tufujie.service.Student">
<property name="name">
<value>Tom</value>
</property>
<property name="age">
<value>21</value>
</property>
</bean>

2.构造函数注入

虽然在Spring中提倡使用Setter方法的方式进行注入，但是使用构造函数是依赖注入非常重要的方式之一。有些程序员更倾向于使用构造函数的方式进行注入，是因为使用这种方式可以将所有属性一次性注入。

使用构造函数进行注入的方式时，必须在Bean程序中声明有参构造函数，其中的参数就是要注入的属性。看下面的Bean程序代码。

<bean id="teacher" class="com.tufujie.service.Teacher">
<constructor-arg type="java.lang.String">
<value>Jerry</value>
</constructor-arg>
<constructor-arg type="int">
<value>32</value>
</constructor-arg>
</bean>

3.注入其他Bean

在前面的学习中，介绍了两种注入的方式，在其中都是通过基本类型和字符串类型进行举例说明的。除此之外，采用将bean中指定属性的值设置为对容器中的另外一个bean的引用的方式，可以在一个Bean中注入其他Bean。该操作是通过<ref>标记对完成，将其放在<constructor-arg>标记对或者<property>标记对中。从这里也可以看出注入其他Bean也是有两种注入方式的，这里我们只以使用Setter方法的方式进行注入。

<bean id="UserDAOImpl" class="com.tufujie.dao.UserDAOImpl"></bean>
<bean id="userService" class="com.tufujie.service.UserServiceImpl">
<property name="userDAO">
<ref bean="UserDAOImpl"/>
</property>
</bean>

4.内部Bean

在Java基本语法中有局部变量的概念，局部变量只能在所在的语句块中使用。同样在Spring中有“局部”Bean，它的标准名称为内部Bean。内部Bean是指注入的Bean只能被它所在的Bean使用，不能再被其他Bean所注入。内部Bean是不需要id属性和name属性的，因为它能做被所在Bean使用，就算设定了id属性和name属性，容器也会将其省略掉。

<bean id="userService"
class="com.tufujie.service.UserServiceImpl">
<property name="userDAO">
<bean class="com.tufujie.dao.UserDAOImpl"/>
</property>
</bean>

5.注入集合

在Java中，集合包括List、Set和Map三种，在Spring除了能够对这三种集合能够注入操作外，还包括Properties映射文件。在Spring配置文件中，使用<list/>、<set/>、<map/>及<props/>标记来对应集合。在这里，我们只给出配置文件代码，读者可以在光盘中查看到Bean代码，在Bean中定义了四种集合变量。

6.空字符串和null值的处理

在Spring中，对空字符串和null值进行注入有不同的。当对空字符串进行注入时，只需要在其中的<value>标记对中不写入任何内容。例如：

<bean class="Teacher">
<property name="name"><value></value></property>
</bean>

它相当于Java中的：teacher.setName(“”);

当对null值进行注入时，需要使用<null>标记，例如：

<bean class="Teacher">
<property name="name"><null/></property>
</bean>

它相当于Java中的：teacher.setName(null);

7.依赖注入的简写形式

在前面的举例中，读者可能会发现当注入值或者其他Bean时，都要在其中使用到<value>标记或者<ref>标记。Spring为了简化该操作，在<property>、<constructor-arg>和<entry>标记中定义了value属性和ref属性来替代<value>标记和<ref>标记。这里我们仅一使用Setter方法方法注入基本数据类型数据为例，如果使用原<value>标记的方式，形式为：

<property name="name">
  <value>Tom</value>
</property>

如果使用value属性的方式，则形式为：<property name="name" value="Tom"/>

8.不完全依赖

在前面学习注入其他Bean时，当Bean甲被依赖注入到Bean乙中时，在Bean乙中就可以使用Bean甲进行调用方法。在其中Bean甲是要在Bean乙之前实例化的。

但是实际开发中有这样一种情况，需要Bean甲在Bean乙之前实例化，但是在Bean乙中是不需要使用Bean甲的，这种情况下就可以使用不完全依赖注入。这种情况在数据库开发中比较常见，例如注册数据驱动必须在所有操作之前完成。

不完全依赖是通过<bean>标记中的depends-on属性完成的，它的属性值就是要在所在Bean之前实例化的Bean。例如：

<bean id="student" class="Student" />

<bean id="teacher" class="Teacher" depends-on=" student "/>

9.自动装配

在Spring中，具有自动装配的方式注入其他Bean，使用该方式可以简化注入Bean的复杂配置。自动装配是通过<bean>标记的autowire属性定义的，该属性可选的属性值有五种，它们各自代表不同的自动装配方式。

◆ no，代表不使用自动装配。

◆ byName ，根据属性名自动装配。

◆ byType， 如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配。

◆ constructor 与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。

◆ autodetect 通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。

Bean作用域

1.Singleton作用域

Singleton作用域是Bean的默认作用域。当一个Bean的作用域为singleton,时，那么在Spring IoC容器中只会存在一个共享的Bean实例。也就是说所有对Bean的请求，只要id与该Bean定义相匹配，则只会返回bean的同一实例。Bean的单一实例存储在单利缓存中，请求和引用该Bean时，将自动调用该缓存中的对象实例。

因为Bean的默认作用域就是Singleton，所以将Bean定义成Singl eton有三种方式，最简单的就是什么都不定义。除此之外，还有如下两种方式：

<bean id="teacher" class="com.Teacher" scope="singleton"/>

<bean id=" teacher " class="com.Teacher" singleton="true"/>

2.Prototype作用域

Prototype作用域是和Singleton作用域相对的。当一个Bean设置为Prototype作用域时，则该Bean每被请求或者引用一次，都会创建一个Bean实例对象。

将Bean的作用域设定为Prototype有两种方式，是和Singleton作用域设定非常相似的，它有两种方式，如下：

<bean id="teacher" class="com.Teacher" scope="prototype"/>

<bean id=" teacher " class="com.Teacher" singleton="flase"/>

3.Request作用域

request、session和global session的作用域是和前面的两种作用域有很大不同的，它们只能应用在Web的项目中。Web中的容器实例化是和前面学过的实例化是有所不同的，它要使用XmlWebApplicationContext来查找Spring配置文件。

在Web中，每次HTTP请求就对应一个request对象。将Bean的作用域设定为request，就表示该Bean只在当前请求中有效。不同请求中的Bean是互相看不到状态变化的。当处理请求结束时，request作用域的Bean实例也就被销毁。request作用域的Bean的配置如下所示：

<bean id="userDAO" class=" com.tufujie.dao.UserDAOImpl" scope="request"/>

4.Session作用域

在Web中，每次HTTP会话就对应一个Session对象。将Bean的作用域设定为session，就表示该Bean只在当前会话中有效。在用户操作比较多的网站中，例如购物网站中，通常一个用户对应一个Session对象。在这种项目中，通过将用户共用的Bean设置为session作用域，这就可以使一个用户不能看到其他用户的状态。

当一次会话结束时，session作用域的Bean实例就会被销毁。session作用域的Bean的配置如下所示：

<bean id="userDAO" class=" com.tufujie.dao.UserDAOImpl" scope="session"/>

5.global session作用域

global session作用域和Session作用域是非常相似的，它在实际开发中是非常少用的。在global session作用域的bean中被限定为全局portlet Session的生命周期范围内。global session作用域的Bean的配置如下所示：

<bean id="userDAO" class=" com.tufujie.dao.UserDAOImpl" scope="globalSession"/>

6.自定义作用域

在Spring 2.0及以上版本中，Spring的作用域中种类是可以扩展的，也就是说我们不但可以使用前面讲解的五种以定义作用域，还可以进行自定义作用操作。

在Spring框架中，作用域是由Scope接口定义的，它接口的全称接口名为org.springframework.beans.factory.config.Scope，在JAR包可以看到该接口的代码。所有的作用域都是实现Scope接口，同样自定义作用域也要实现该接口，并且要实现该接口中的方法，分别是底层存储机制获取和删除对象方法。

自定义完作用域类后，还需要对其进行配置，然后在其他Bean中才能使用。由于该知识点是比较复杂的，在实际开发中使用的也不是很多，这里就仅对功能进行简单讲解。

面向切面编程

在本章中继续学习Spring的第二大功能，那就是面向切面编程。在前面学习Java时，我们知道Java是一门面向对象的语言，在学习Java之前，读者可能还学习过面向过程的语言，这些都是编程思想。面向切面编程在一定程度上弥补了面向对象编程的不足，面向对象编程是对父类子类这种纵向关系编程，而面向切面编程是在方法的前后进行横向关系编程。面向切面编程的缩写是AOP，在本章中就来对AOP的技术进行详细讲解。

重点内容：

了解面向切面编程概念

通过注解的方式进行面向切面编程

通过配置的方式进行切面编程

面向切面编程简介

1.面向切面编程概念

首先来看切面，如果读者是山西人的话，看到切面的概念，肯定会首先想到刀削面。Spring中的“切面”就是刀削面中的那把刀，使用这把刀可以将一个事物一分为二。Spring中的“切面”就是这个作用，它可以将一个程序分为两部分，并在中间加入自己想做的事，并且它可能不仅仅对一个程序，而且是一个包下的所有程序。

在一个程序使用切面，通常是对程序中的方法进行操作，方法调用和处理异常等时间段就称为连接点。在Spring的面向切面编程中，一个连接点就代表一个方法的执行。在一个连接点中，有分为很多个切入点，例如方法调用前，方法调用后等。在Spring中，执行切面编程是通过拦截器的概念，当运行到某一切入点时，会告诉拦截器，这就是通知的概念。

2.面向切面编程的功能

Spring AOP是使用纯Java编写的，所以在我们的程序中可以无缝使用，并很容易完成对它的扩展。在目前的Spring的面向切面编程中仅支持以方法做为连接点。如果读者向完成成员变量的连接点操作，可以扩展Spring框架。只所在在Spring框架中仅仅做了方法的功能，是因为在实际开发中应用最多的就是它，对于成员变量的操作是非常少的。

在后面的学习中，就重要来学习Spring中使用面向切面编程对程序中的方法进行操作。通过这种操作，是方法的功能更加丰富。

使用注解方式进行AOP开发

1.启动AspectJ的支持

要想在Spring的面向切面开发中使用注解方式，就需要使用到AspectJ组件技术。要使用AspectJ技术首先要导入AspectJ相关的两个JAR，分别是aspectjweaver.jar 和aspectjrt.jar，它们位于lib/aspectj目录下。

除了需要导入AspectJ相关JAR外，还需要在Spring的配置文件，通常是applicationContext.xml文件，在其中加入相应的配置，其代码如下所示。

<aop:aspectj-autoproxy/>

2.声明切面

在完成上一小节的内容的基础上，在Spring中开发Bean程序时，需要在Bean类的前面加入@AspectJ，从而标明该类是Spring中的切面。

@Aspect

public class BooksServiceImpl{

}

开发完Bean后，同样需要在Spring配置文件中进行配置，例如：

<bean id="booksServiceImpl" class="BooksServiceImpl"></bean>

可以看到对声明切面的Bean进行配置时，和普通的Bean是没有任何区别的。

3.声明切入点

切入点决定了连接点关注的内容，使得我们可以控制通知什么时候执行。在前面学习中已经知道面向切面编程仅对方法执行，所以切入点也仅仅是判断哪些方法需要进行面向切面编程。

声明切入点是需要使用@Pointcut注解，在后面给出切入点表达式，定义关注哪些方法的执行。后面还要给出一个切入点名称，它通过一个没有返回值的普通方法来构成。例如：

@Pointcut("execution(* com.tufujie.dao..*.*(..) ")

private void allMethod(){};

其中“@Pointcut”是声明切入点的固定格式。“execution(* com.tufujie.dao..*.*(..)”是切入点表达式，它的使用是AspectJ的核心技术，在后面会对其进行讲解。“allMethod”是切入点的名称。

4.声明通知

声明通知的作用是告诉程序当在切入点的什么时刻执行下面的方法。目前的通知方式有前置通知、返回后通知、抛出异常后通知和后通知。其中前置通知是指在切入点方法运行之前进行通知，从而执行下面的方法，使用的是@Before注解。例如：

@Before("allMethod ()")

private void myBeforeMethod() {

}

其中“@Before”是声明通知的固定格式，“allMethod”是切入点的名称，和声明切入点时相对应。下面的“myBeforeMethod”方法是定义的要执行的方法。

切入点

1.切入点指定者

在进行Spring面向切面编程时，支持在切入点表达式中使用很多种AspectJ切入点指定者，其中使用最多的就是前面使用到的execution，通过它来匹配方法执行的连接点。除了execution切入点指定者外，还包括如下几种比较常用的。

◆ within：通过限定匹配特定类型确定连接点。

◆ this：通过指定类型的实例确定连接点。

◆ target：通过目标对象确定连接点。

◆ args：通过参数确定连接点。

2.合并切入点

在Java中有“&&”、“||”和“！”三种短路逻辑运算符，在切入点表达式中也可以使用这三种逻辑运算符，其中最常用的就是“||”，它表示两边的方法都可以声明切入点，例如：

@Pointcut("execution(* com.tufujie.dao.*.*(..)) || execution(* com.tufujie.service.*.*(..))")

上面的切入点表达式表示不管是dao包下的接口还是service包下的接口内的所有方法都会定义成后面的切入点，从而使它们都能够进行面向切面开发。

3.切入点表达式

在前面的学习中，读者可能对切入点表达式有很大疑惑。在本节中就通过execution切入点指定者来讲解切入点表达式，其语法格式为如下。

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern))

其中“modifiers-pattern”表示访问修饰符，它是可选的。“ret-type-pattern”表示返回类型，它是必须的，当使用“*”时，表示可以是任意返回类型。“declaring-type-pattern”表示全程限定的类型名，它也是可选的。“name-pattern”表示限定的方法名，它是必须的，使用“*”可以匹配全部或者某一种类方法。“param-pattern”表示参数，当为空时表示无参数方法，当为“..”时表示匹配任意数量参数的方法，在参数中也可以指定特定的类型。

通知

1.返回后通知

返回后通知是指当匹配的方法执行retrun语句返回值时进行通知，它使用“@AfterReturning”注解进行声明，基本形式为：

@AfterReturning("allMothod()") //声明通知

public void myAfterReturningMethod(){ //定义通知方法

}

从形式上可以看出，这种返回后通知是和前面学习的前置通知非常相似的。

在使用返回后通知时，在通知方法中经常想要得到方法的返回值，这就需要使用到returning子句。

2.抛出后通知

抛出后通知是指当执行匹配方法抛出异常后进行通知，它使用“@AfterThrowing”注解进行声明，基本形式为：

@AfterThrowing("allMothod()") //声明通知

public void myAfterThrowingMethod(){ //定义通知方法

}

抛出后通知是和返回后通知有很大相似的地方的，在通知方法中也可以得到匹配方法抛出的异常，这里要使用到throwing子句。通过使用throwing子句也可以对匹配方法通过抛出异常进行限制，如果不想限制，可以使用所有异常的父类Throwable为类型。

3.后通知

后通知是指当当匹配的方法执行结束后通知，它使用“@After”注解进行声明。需要注意的是，方法的结束有多种情况，例如正常运行结束、返回值后结束和发生异常，不管是哪种方式的结束都会进行后通知。后通知的基本形式为：

@After("allMothod()") //声明通知

public void myAfterMethod(){ //定义通知方法

}

后通知和前置通知非常相似的，也是非常容易学习的，这里就不在举例讲解。

4.环绕通知

环绕通知是前置通知和后通知的结合体，使用环绕通知可以使一个方法的前后都执行通知方法。并且通过环绕通知可以决定方法什么时候执行，如何执行和是否执行。

环绕同时是使用“@Around”注解声明的，在其中指定切入点名称。在通知方法中必须要有一个ProceedingJoinPoint类型的参数。在通知方法内可以使用ProceedingJoinPoint类型参数调用proceed方法可以导致潜在的连接点方法的执行。proceed方法具有参数为Object对象数组的重载方式，通过该方法可以传入方法执行时候的参数。环绕通知的基本形式如下：

@Around("allMothod()") //声明通知
public void myAfterMethod(ProceedingJoinPoint pjp){
Object retVal = pjp.proceed();
return retVal;
}

5.通知顺序

当进行数据库开发时，有这样一种情况，在执行数据库操作执行后，不但要关闭数据库资源，还要关闭数据库。当我们通过切面编程完成该功能时，就要写两个通知方法，这就出现通知顺序的问题，也就是在同一时刻有两个通知方法要执行。

如果两个通知方法在同一个切面中，该通知顺序是非常简单的，根据声明顺序来确定执行顺序，声明在前，则执行通知方法的时候也在前。

如果两个通知方法不在同一切面中，这时不进行设置，则执行顺序是不确定的，这在实际开发中就可能出现问题。在线程中，我们可以通过设置线程的优先级来设置线程执行的优先性。同样通知方法也有优先级，在Spring中可以实现“org.springframework.core.Ordered”接口，通过该接口可以获取和设置通知方法的优先级。

使用配置方式进行AOP开发

1.配置声明切面

在配置方式进行AOP开发中，可以将声明切面的类做为普通的类配置到Spring容器中，从而做为一个Bean进行操作，不过这需要给出相应的schema支持。

声明切面是通过<aop:aspect>标记对来声明的，在其中使用id属性指定切面名称，使用ref属性指定切面类Bean的id名称。例如：

<aop:config>
  <aop:aspect id="myAspect" ref="aspectJXML">
...
  </aop:aspect>
</aop:config>
<bean id="aspectJXML" class=" com.tufujie.service.AspectJXML">
</bean>

切面类Bean是其他Bean一样，都可以由Spring容器进行管理配置和依赖注入操作。

2.配置声明切入点

使用配置方法进行AOP开发时，声明切入点有两种配置方法，根据作用范围的不同，切入点可以分为全局切入点和局部切入点。声明切入点是通过<aop:pointcut>标记对声明的，当进行全局切入点声明式，要求将<aop:pointcut>标记对直接配置到<aop:config>标记对，这样就可以使多个切面和通知共享该切入点。全局切入点的声明如下：

<aop:config>
  <aop:pointcut id="allMothod" expression="execution(* com.tufujie.dao.*.*(..))"/>
</aop:config>

声明局部切入点时需要将<aop:pointcut>标记对配置到表示切面的<aop:aspect>标记对中，从而在该切面中声明切入点。

3.配置声明通知

通知的种类在前面的学习中已经讲解过，使用不同方式进行AOP开发是不影响通知种类的。这里我们仍然通过前置通知将进行讲解，它需要使用<aop:before>标记对进行配置，它需要配置在切面中，也就是<aop:aspect>标记对中，例如：

<aop:config>
  <aop:aspect id="myAspect" ref="aspectJXML">
<aop:pointcut id="allMothod" expression="execution(* com.tufujie.dao.*.*(..))"/>
<aop:before pointcut-ref="allMothod" method="myBeforeMethod"/>
  </aop:aspect>
</aop:config>
<bean id="aspectJXML" class=" com.tufujie.service.AspectJXML">
</bean>

面向切面编程API介绍

1.处理切入点

先来看一下在Spring中是如何处理切入点的。在Spring中定义了切入点模型，该模型的核心处理接口为“org.springframework.aop.

Pointcut”，使用该接口可以使切入点和通知相分离，从而使一个切入点可以被多个通知使用。切入点模型的Pointcut接口的代码为：

public interface Pointcut {
    ClassFilter getClassFilter();
    MethodMatcher getMethodMatcher();
}

2.处理通知

在本节中继续学习Spring中是如何处理通知的。在Spring中，每一种通知都是一个Bean。在其中可以设置类共享或者实例共享的参数，从而设定一个通知实例是被所有被通知的对象共享，还是被每一个被通知对象独占。Spring中已经定义了多种通知类型，这个在前面的学习中已经讲解过。这里我们先来看一下最简单的前置通知是如何实现的。

前置通知是通过MethodBeforeAdvice接口完成的，它的代码为：

public interface MethodBeforeAdvice extends BeforeAdvice {
    void before(Method m, Object[] args, Object target)  throws Throwable;
}

3.使用AOP的工厂Bean

在学习Spring的依赖注入时，经常会提到依赖注入的Bean工厂。同样在进行面向切面编程时，也有AOP的工厂Bean。通过使用面向切面的工厂Bean，可以对应用的切入点和通知进行管理。处理AOP的工厂Bean的全称接口名为“org.springframework.aop.framework.Proxy

FactoryBean”。

在Spring中大量使用了代理设计模式，使用ProxyFactoryBean接口引用调用getObject方法将产生一个工厂Bean的代理对象，它就是AOP代理。使用AOP代理的一个直接好处就是可以让IoC容器操作切入点和通知。

ProxyFactoryBean类中具有很多属性，这些属性一部分是自定义的，另一大部分是继承来来的。通过使用这些属性可以指定希望代理的目标对象和指定是否使用CGLIB。

在Spring中进行JDBC编程

1.Spring中的数据库操作封装类

Spring中的数据库操作封装类是JdbcTemplate，它位于“org.

springframework.jdbc.core”包下。使用该类可以完成数据库的连接和关闭，从而简化JDBC操作。JdbcTemplate将完成JDBC核心处理流程，例如SQL语句的创建、执行，而把SQL语句的生成以及查询结果的提取工作留给程序员写的应用代码。

创建JdbcTemplate类对象，通常要使用到DataSource接口参数，DataSource接口将在下一小节中进行讲解。JdbcTemplate类和普通的Bean一样，可能直接使用Java代码进行实例化，也可以通过使用Spring的IoC容器进行实例化。

2.数据源接口

数据源接口也就是DataSource接口，通过使用该接口可以创建一个数据库连接。DataSource接口也称为数据源接口，在Spring中有多种创建数据源的方式，例如JNDI、第三方连接池等。在本书中主要来通过Spring配置的方式建立数据源。在前面学习JDBC和Hibernate时已经知道，要想连接数据库，最少要知道数据库的驱动、url、用户名和密码，所以在配置DataSource接口时需要给出这些信息。

<bean id="dataSource" class="org.springframework.jdbc.datas
ource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
。。。。
</bean>

3.执行SQL语句

学习完Spring中的数据库操作封装类和数据源接口，现在就可以结合使用它们进行数据库开发，先来看一下如何进行基本的SQL语句运行。

private JdbcTemplate jt;
private DataSource dataSource;
public void setDataSource(DataSource dataSource) { this.dataSource = dataSource;

}
public void doExecute() {
    jt = new JdbcTemplate(dataSource);
    jt.execute("create table user (id integer, name  varchar(100))");
}

4.更新数据库操作

更新数据库操作中包括插入、修改和删除三种三种，这三种操作都是通过update方法完成的。在update方法中给出SQL语句参数，从而完成相应的数据库操作。

private JdbcTemplate jt;
private DataSource dataSource;
public void setDataSource(DataSource dataSource){
    this.dataSource = dataSource;
}

public void doUpdate() {
    jt = new JdbcTemplate(dataSource);
jt.update("insert into user values (1,'Tom')");
}

5.查询数据库操作

创建数据表，并且向其中插入数据后，就可以通过查询操作将数据表中的数据查询出来。在Spring的封装数据库中查询数据的方法有很多，这里我们使用其中的两个，分别是查询一个数据和查询所有数据。

public String doGetName() {
     jt = new JdbcTemplate(dataSource);
     String name=(String)jt.queryForObject("select name
from user where id=1", String.class);
     return name;
}

public List doGetNames(){
jt = new JdbcTemplate(dataSource);
List list=jt.queryForList("select name from user");
return list;
}