Spring学习整理

Spring

Spring的介绍/优点

Spring 是一个开源应用框架，旨在降低应用程序开发的复杂度。它是轻量级、松散耦合的。它具有分层体系结构，允许用户选择组件，同时还为 J2EE 应用程序开发提供了一个有凝聚力的框架。它可以集成其他框架，如 Structs、Hibernate、EJB 等，所以又称为==框架的框架==。

优势：由于 Spring Frameworks 的分层架构，用户可以自由选择自己需要的组件。Spring Framework 支持 POJO(Plain Old Java Object) 编程，从而具备持续集成和可测试性。由于依赖注入和控制反转，JDBC 得以简化。它是开源免费的。

• 轻量级：Spring 在代码量和透明度方面都很轻便，基本的版本大约 2MB。
• 非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API
• IOC：Spring 通过控制反转实现了松散耦合，将对象的创建权交给 Spring 去统一管理。
• DI：指依赖的对象不需要手动调用 setXX 方法去设置，而是通过配置赋值。
• AOP：面向切面编程可以将应用==业务逻辑和系统服务==分离，以实现高内聚低耦合。
• 容器：Spring 负责创建和管理对象（Bean）的生命周期和配置。
• MVC：对 web 应用提供了高度可配置性，其他框架的集成也十分方便。
• 事务管理：提供了用于事务管理的通用抽象层。Spring 的事务支持也可用于容器较少的环境。
• 异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC抛出的）转化为一致的 unchecked 异常。
• 组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。
• 一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上 Spring 自身也提供了表现层的 SpringMVC 和持久层的 Spring JDBC）

三层架构

1. 表现层 web层 MVC是表现层的一个设计模型
2. 业务层 service层
3. 持久层 dao层

Spring的模块

核心容器

• spring-core 模块提供了框架的基本组成部分，包括 IoC 和依赖注入功能。
• spring-beans 模块提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。
• context 模块建立在由 core和 beans 模块的基础上建立起来的，它以一种类似于 JNDI 注册的方式访问对象。Context 模块继承自 Bean 模块，并且添加了国际化（比如，使用资源束）、事件传播、资源加载和透明地创建上下文（比如，通过 Servelet 容器）等功能。Context 模块也支持 Java EE 的功能，比如 EJB、JMX 和远程调用等。
  • ApplicationContext 接口是 Context 模块的焦点。
  • spring-context-support 提供了对第三方集成到 Spring 上下文的支持，比如缓存（EhCache, Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker, JasperReports, Velocity）等。
• spring-expression 模块提供了强大的表达式语言，用于在运行时查询和操作对象图。它是 JSP2.1 规范中定义的统一表达式语言的扩展，支持 set 和 get 属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从 Spring IoC 容器检索对象，还支持列表的投影、选择以及聚合等。
• 依赖关系图：
  

数据集成/访问

• JDBC【Java Data Base Connectivity】 模块提供了 JDBC 抽象层，它消除了冗长的 JDBC 编码和对数据库供应商特定错误代码的解析。
• ORM【Object Relational Mapping】 模块提供了对流行的对象关系映射 API 的集成，包括 JPA、JDO 和 Hibernate 等。通过此模块可以让这些 ORM 框架和 spring的其它功能整合，比如前面提及的事务管理。
• OXM【Object XML Mapping】 模块提供了对 OXM 实现的支持，比如 JAXB、Castor、XML Beans、JiBX、XStream 等。
• JMS【Java Message Servic】 模块包含生产（produce）和消费（consume）消息的功能。从 Spring 4.1 开始，集成了 spring-messaging 模块。
• **事务 **模块为实现特殊接口类及所有的 POJO 支持编程式和声明式事务管理。（注：编程式事务需要自己写 beginTransaction()、commit()、rollback() 等事务管理方法，声明式事务是通过注解或配置由 spring 自动处理，编程式事务粒度更细）

Web

• Web 模块提供面向 web 的基本功能和面向 web 的应用上下文，比如多部分（multipart）文件上传功能、使用 Servlet 监听器初始化 IoC 容器等。它还包括 HTTP 客户端以及 Spring 远程调用中与 web 相关的部分。
• Web-MVC 模块为 web 应用提供了模型视图控制（MVC）和 REST Web服务的实现。Spring 的 MVC 框架可以使领域模型代码和 web 表单完全地分离，且可以与 Spring 框架的其它所有功能进行集成。
• Web-Socket 模块为 WebSocket-based 提供了支持，而且在 web 应用程序中提供了客户端和服务器端之间通信的两种方式。
• Web-Portlet 模块提供了用于 Portlet 环境的 MVC 实现，并反映了 spring-webmvc 模块的功能。

其他

• AOP 模块提供了面向方面（切面）的编程实现，允许你定义方法拦截器和切入点对代码进行干净地解耦，从而使实现功能的代码彻底的解耦出来。使用源码级的元数据，可以用类似于.Net属性的方式合并行为信息到代码中。
• Aspects 模块提供了与 AspectJ 的集成，这是一个功能强大且成熟的面向切面编程（AOP）框架。
• Instrumentation 模块在一定的应用服务器中提供了类 instrumentation 的支持和类加载器的实现。
• Messaging 模块为 STOMP 提供了支持作为在应用程序中 WebSocket 子协议的使用。它也支持一个注解编程模型，它是为了选路和处理来自 WebSocket 客户端的 STOMP 信息。
• **测试 **模块支持对具有 JUnit 或 TestNG 框架的 Spring 组件的测试。

IOC容器

==Spring 容器是 Spring 框架的核心。==容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。Spring 容器使用依赖注入（DI）来管理组成一个应用程序的组件。容器通过读取提供的配置元数据来接收对象进行实例化，配置和组装的指令。该元数据可以通过 XML，Java 注解或 Java 代码提供。

IOC的优势在于：

• 它将最小化应用程序中的代码量。
• 它将使您的应用程序易于测试，因为它不需要单元测试用例中的任何单例或 JNDI 查找机制。
• 它以最小的影响和最少的侵入机制促进松耦合。
• 它支持即时的实例化和延迟加载服务。

IOC代码实现

interface Fruit {
    public abstract void eat();
}

class Apple implements Fruit {
    public void eat(){
		System.out.println("Apple");
	}
}

class Orange implements Fruit {
	public void eat(){
		System.out.println("Orange");
	}
}

class Factory {
	public static Fruit getInstance(String ClassName) {
		Fruit f=null;
		try {
			f=(Fruit)Class.forName(ClassName).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return f;
	}
}

class Client {
	public static void main(String[] a) {
		Fruit f=Factory.getInstance("io.github.dunwu.spring.Apple");
		if(f!=null){
			f.eat();
		}
	}
}

IOC容器种类

BeanFactory

它就像一个包含 bean 集合的工厂类。它会在客户端要求时实例化 bean。这是一个最简单的容器，它主要的功能是为依赖注入 （DI） 提供支持，在 Spring 中，有大量对 BeanFactory 接口的实现。其中，最常被使用的是 XmlBeanFactory 类。这个容器从一个 XML 文件中读取配置元数据，由这些元数据来生成一个被配置化的系统或者应用。在资源宝贵的移动设备或者基于 applet 的应用当中， BeanFactory 会被优先选择。否则，一般使用的是 ApplicationContext，除非你有更好的理由选择 BeanFactory。

代码演示：

public class HelloWorld {
	private String message;
    
	public void setMessage(String message){
		this.message  = message;
	}
    
	public void getMessage(){
		System.out.println("Your Message : " + message);
	}
}

xml配置文件

<bean id="helloWorld" class="com.tutorialspoint.HelloWorld">
    <property name="message" value="Hello World!"/>
</bean>

main类

public class MainApp {
    public static void main(String[] args) {
        XmlBeanFactory factory = new XmlBeanFactory(
            new ClassPathResource("Beans.xml"));
        HelloWorld obj = (HelloWorld) factory.getBean("helloWorld");
        obj.getMessage();
    }
}

• 第一步利用框架提供的 XmlBeanFactory() API 去生成工厂 bean 以及利用 ClassPathResource() API 去加载在路径 CLASSPATH 下可用的 bean 配置文件。XmlBeanFactory() API 负责创建并初始化所有的对象，即在配置文件中提到的 bean。
• 第二步利用第一步生成的 bean 工厂对象的 getBean() 方法得到所需要的 bean。 这个方法通过配置文件中的 bean ID 来返回一个真正的对象，该对象最后可以用于实际的对象。一旦得到这个对象，你就可以利用这个对象来调用任何方法。

ApplicationContext【Spring上下文】

Application Context 是 BeanFactory 的子接口，它扩展了 BeanFactory 接口，它可以加载配置文件中定义的 bean，将所有的 bean 集中在一起，当有请求的时候分配 bean。 另外，它增加了企业所需要的功能，比如，从属性文件中解析文本信息和将事件传递给所指定的监听器。

最常被使用的 ApplicationContext 接口实现：

• FileSystemXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你需要提供给构造器 XML 文件的完整路径。

  public class MainApp {
     public static void main(String[] args) {
        ApplicationContext context = new FileSystemXmlApplicationContext
              ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
     }
  }
  

• ClassPathXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你不需要提供 XML 文件的完整路径，只需正确配置 CLASSPATH 环境变量即可，因为，容器会从 CLASSPATH 中搜索 bean 配置文件。

  public class MainApp {
     public static void main(String[] args) {
        ApplicationContext context = 
               new ClassPathXmlApplicationContext("Beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
     }
  }
  

• WebXmlApplicationContext：该容器会在一个 web 应用程序的范围内加载在 XML 文件中已被定义的 bean。

Spring Bean

它是构成应用程序的支柱，基于用户提供给容器的配置元数据创建，由 Spring IoC 容器实例化，配置，装配和管理。

属性名称	描述
id	是一个 Bean 的唯一标识符，Spring 容器对 Bean 的配置和管理都通过该属性完成
name	Spring 容器同样可以通过此属性对容器中的 Bean 进行配置和管理，name 属性中可以为 Bean 指定多个名称，每个名称之间用逗号或分号隔开
class	该属性指定了 Bean 的具体实现类，它必须是一个完整的类名，使用类的全限定名
scope	用于设定 Bean 实例的作用域，其属性值有 singleton（单例）、prototype（原型）、request、session 和 global Session。其默认值是 singleton
constructor-arg	元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型
property	元素的子元素，用于调用 Bean 实例中的 Set 方法完成属性赋值，从而完成依赖注入。该元素的 name 属性指定 Bean 实例中的相应属性名
Autowiring mode	它是用来注入依赖关系的。
lazy-initialization mode	延迟初始化的 bean 告诉 IoC 容器在它第一次被请求时，而不是在启动时去创建一个 bean 实例。
initialization	在 bean 的所有必需的属性被容器设置之后，调用回调方法。
destruction	当包含该 bean 的容器被销毁时，使用回调方法。
ref	和 等元素的子元索，该元素中的 bean 属性用于指定对 Bean 工厂中某个 Bean 实例的引用
value	和 等元素的子元素，用于直接指定一个常量值
list	用于封装 List 或数组类型的依赖注入
set	用于封装 Set 类型属性的依赖注入
map	用于封装 Map 类型属性的依赖注入
entry

五种 bean 的作用域：

作用域	描述
singleton	在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，默认值
prototype	每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean()
request	每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境
session	同一个HTTP Session共享一个Bean，不同Session使用不同的Bean，仅适用于WebApplicationContext环境
global-session	一般用于Portlet应用环境，该作用域仅适用于WebApplicationContext环境

Bean配置方式

基于 xml 配置

bean 所需的依赖项和服务在 XML 格式的配置文件中指定，该文件主要包含类信息。它描述了这些类是如何配置以及相互引入的。如果没有正确规划和编写，那么在大项目中管理变得非常困难。这些配置文件通常包含许多 bean 定义和特定于应用程序的配置选项。它们通常 bean 标签开头。例如：

<bean id="studentbean" class="org.edureka.firstSpring.StudentBean">
	<property name="name" value="Edureka"></property>
</bean>

内部bean定义示例：

public class Student {
	private Person person;
	//Setters and Getters
}

public class Person {
	private String name;
	private String address;
	//Setters and Getters
}

<bean id="StudentBean" class="com.edureka.Student">
	<property name="person">
        <!--This is inner bean -->
        <bean class="com.edureka.Person">
        <property name="name" value="Scott"></property>
        <property name="address" value="Bangalore"></property>
        </bean>
    </property>
</bean>

在启动类加载xml文件

public class Main {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = 
            new ClassPathXmlApplicationContext("config.xml");
        Student student = context.getBean("student",Student.class);
    }
}

基于注解配置

可以通过在相关的类，方法或字段声明上使用注解，将 bean 配置为组件类本身，而不是使用 XML 来描述 bean 装配。

注解区别【四个实现功能是一样的】：

@Component ：业务特殊组件层，如handler类，将 java 类标记为 bean。
@Controller ：业务控制层，这将一个类标记为 Spring Web MVC 控制器。
@Service ：业务逻辑层，此注解是组件注解的特化。它不会对 @Component 注解提供任何其他行为。
@Repository ：业务资源层，这个注解是具有类似用途和功能的 @Component 注解的特化。它将 DAO 导入 IoC 容器，并使未经检查的异常有资格转换为 Spring DataAccessException。

默认情况下，Spring 容器中未打开注解装配。因此，您需要在使用它之前在 Spring 配置文件中启用它。

<beans>
	<context:annotation-config/>
	<!-- bean definitions go here -->
</beans>

在类上注解

@Component
public class Student {
	private Person person;
	//Setters and Getters
}

public class Person {
	private String name;
	private String address;
	//Setters and Getters
}

config类定义扫描范围

@ComponentScan("com.shi")
public class StudentConfig {
    
}

主类启动

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new 
            AnnotationConfigApplicationContext(StudentConfig.class);
        Student student = context.getBean("student",Student.class);
    }
}

基于JAVA配置

Spring 的 Java 配置是通过使用 @Bean 和 @Configuration 来实现。 @Configuration 类允许通过简单地调用同一个类中的其他 @Bean 方法来定义 bean 间依赖关系。
例如：

@Configuration
public class StudentConfig {
	@Bean
	public StudentBean myStudent() {
		return new StudentBean();
	}
}

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new 
            AnnotationConfigApplicationContext(StudentConfig.class);
        Student student = context.getBean("student",Student.class);
    }
}

还有一个注释叫==@Import==

@Configuration
public class ConfigA {
   @Bean
   public A a() {
      return new A(); 
   }
}

@Configuration
@Import(ConfigA.class)
public class ConfigB {
   @Bean
   public B b() {
      return new B(); 
   }
}

这样就可以只导入B的config类。

public static void main(String[] args) {
   ApplicationContext ctx = 
   new AnnotationConfigApplicationContext(ConfigB.class);
   // now both beans A and B will be available...
   A a = ctx.getBean(A.class);
   B b = ctx.getBean(B.class);
}

@Bean和@Component的区别

1、@Component注解表明一个类会作为组件类，并告知Spring要为这个类创建bean。

2、@Bean注解告诉Spring这个方法将会返回一个对象，这个对象要注册为Spring应用上下文中的bean。通常方法体中包含了最终产生bean实例的逻辑。

两者的目的是一样的，都是注册bean到Spring容器中。

区别：

@Component（@Controller、@Service、@Repository）通常是通过类路径扫描来自动侦测以及自动装配到Spring容器中。

而@Bean注解通常是我们在标有该注解的方法中定义产生这个bean的逻辑。

@Component 作用于类，@Bean作用于方法。

总结：

@Component和@Bean都是用来注册Bean并装配到Spring容器中，但是Bean比Component的自定义性更强。可以实现一些Component实现不了的自定义加载类。

bean生命周期【循环依赖】

实例化Spring容器**【一切的开端】——进行扫描——解析扫描到的类——反射后实例化这个类所对应的beanDefinition对象——放入beanDefinitionMap——遍历beanDefinitionMap——遍历完成进行验证【是否单例、原型、懒加载、抽象、factoryBean、有无depends on】——去单例池中查找是否有，发现没有——去二级缓存找，发现没有提前暴露——准备开始创建bean——推断构造方法——通过构造方法反射实例化Java对象——对Java对象进行初始化操作**【判断是否支持循环依赖：YES，同时调用后置处理器的before方法】——生成ObjectFactory对象放到二级缓存map中——准备属性注入，发现需要另外一个类Y——开始Y的上述过程直到Y的属性注入，发现需要X——去单例中找X发现没有——去二级缓存找，找到并注入X的objectFactory对象——完成循环依赖——回到X的流程继续——各类Aware接口的回调【先执行BeanNameAware接口的setBeanName方法，再执行ApplicationContextAware接口的setApplicationContext方法】——对X的后续包装，如果有设置AOP的生成代理类——发布事件——最后放入单例池——最后执行自定义的销毁方法

1、为什么要使用X的objectFacory对象而不是直接使用X对象？
利于拓展，程序员可以通过beanPostProcess接口操作objectFactory对象生成自己想要的对象

2、是不是只能支持单例(scope=singleton)而不支持原型(scope=prototype)？

是。因为单例是spring在启动时进行bean加载放入单例池中，在依赖的bean开始生命周期后，可以直接从二级缓存中取到它所依赖的bean的objectFactory对象从而结束循环依赖。而原型只有在用到时才会走生命周期流程，但是原型不存在一个已经实例化好的bean，所以会无限的创建->依赖->创建->依赖->。。。

3、循环依赖是不是只支持非构造方法？
是。否则会出现死锁问题

后置处理器

bean在创建过程中还有后置处理器在bean初始化前后进行处理

BeanPostProcessor 接口定义回调方法，你可以实现该方法来提供自己的实例化逻辑，依赖解析逻辑等。你也可以在 Spring 容器通过插入一个或多个 BeanPostProcessor 的实现来完成实例化，配置和初始化一个bean之后实现一些自定义逻辑回调方法。你可以配置多个 BeanPostProcessor 接口，通过设置 BeanPostProcessor 实现的 Ordered 接口提供的 order 属性来控制这些 BeanPostProcessor 接口的执行顺序。

代码示例：

public class HelloWorld {
	private String message;
	public void setMessage(String message){
  		this.message  = message;
	}
	public void getMessage(){
		System.out.println("Your Message : " + message);
	}
    //初始化方法
	public void init(){
		System.out.println("Bean的初始化");
	}
    //销毁方法
	public void destroy(){
		System.out.println("Bean的销毁");
	}
}

定义后置处理器

public class InitHelloWorld implements BeanPostProcessor {

    //定义初始化前的操作，这里传入bean的类甚至可以和返回的类不一样【狸猫换太子】
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("初始化前 : " + beanName);
		return bean;  
	}
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("初始化后 : " + beanName);
		return bean;  
	}
}

这里就用xml注册了

<!--注册bean，并且用init-method和destroy-method属性分别注册初始化和销毁方法-->
<bean id="helloWorld" class="com.tutorialspoint.HelloWorld"
	init-method="init" destroy-method="destroy">
	<property name="message" value="Hello World!"/>
</bean>

<!--注册后置处理器，可以看到后置处理器是不需要和bean实例绑定的
也就是说这个影响是全局的，对每一个bean都有效，所以可以在方法中判断是不是需要对某个特定类名作用-->
<bean class="com.tutorialspoint.InitHelloWorld" />

主启动类

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
      HelloWorld obj = context.getBean("helloWorld", HelloWorld.class);
      obj.getMessage();
       //这里是关闭容器，close()方法也行，可以显示destroy方法效果
      context.registerShutdownHook();
   }
}

/*
初始化前 : helloWorld
Bean的初始化
初始化后 : helloWorld
Your Message : Hello World!
Bean的销毁
*/

依赖注入DI

构造器注入

当容器调用带有多个参数的构造函数类时，实现基于构造函数的 DI，每个代表在其他类中的一个依赖关系。

public class Foo {
   public Foo(Bar bar, Baz baz) {
      // 拥有多个参数的构造器
   }
}

<beans>
	<bean id="foo" class="x.y.Foo">
		<!--根据位置来判断前后参数-->
		<constructor-arg ref="bar"/>
		<constructor-arg ref="baz"/>
	</bean>

	<bean id="bar" class="x.y.Bar"/>
	<bean id="baz" class="x.y.Baz"/>
</beans>

一些基本类型或者String甚至可以直接注入值

<bean id="exampleBean" class="examples.ExampleBean">
	<constructor-arg type="int" value="2001"/>
	<constructor-arg type="java.lang.String" value="Zara"/>
</bean>

Setter方法注入

基于 setter 方法的 DI 是通过在调用无参数的构造函数或无参数的静态工厂方法实例化 bean 之后容器调用 beans 的 setter 方法来实现的。

没有定义有参构造的类

//主类
public class TextEditor {
	private SpellChecker spellChecker;
	// setter方法
	public void setSpellChecker(SpellChecker spellChecker) {
		System.out.println("Inside setSpellChecker." );
		this.spellChecker = spellChecker;
	}
	// getter方法
	public SpellChecker getSpellChecker() {
		return spellChecker;
	}
	public void spellCheck() {
		spellChecker.checkSpelling();
	}
}

//依赖的类
public class SpellChecker {
	public SpellChecker(){
		System.out.println("Inside SpellChecker constructor." );
	}
	public void checkSpelling() {
		System.out.println("Inside checkSpelling." );
	}  
}

<!-- 其实使用方法和构造器注入是一样的，只是标签名变了
即你要么给构造方法，要么给属性加Setter方法 -->
<bean id="textEditor" class="com.tutorialspoint.TextEditor">
	<property name="spellChecker" ref="spellChecker"/>
</bean>

<bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean>

【注意】：唯一的区别就是在基于构造函数注入中，我们使用的是〈bean〉标签中的〈constructor-arg〉元素，而在基于设值函数的注入中，我们使用的是〈bean〉标签中的〈property〉元素。如果要把一个引用传递给一个对象，那么你需要使用 标签的 ref 属性，而如果你要直接传递一个值，那么你应该使用 value 属性。

xml其实还可以用**p命名空间**来简化代码

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<!--上面的代码可以简化为-->
	<bean id="textEditor" class="com.tutorialspoint.TextEditor"
		p:spellChecker="spellChecker"/>
	</bean>

	<bean id="spellChecker" class="com.tutorialspoint.SpellChecker"/>
</beans>

也可以考虑用内部bean

<bean id="textEditor" class="com.tutorialspoint.TextEditor">
	<property name="spellChecker">
		<bean id="spellChecker" class="com.tutorialspoint.SpellChecker"/>
	</property>
</bean>

集合注入

元素	描述
	它有助于连线，如注入一列值，允许重复。
	它有助于连线一组值，但不能重复。
	它可以用来注入名称-值对的集合，其中名称和值可以是任何类型。
	它可以用来注入名称-值对的集合，其中名称和值都是字符串类型。

<bean id="javaCollection" class="com.tutorialspoint.JavaCollection">

    <!-- results in a setAddressList(java.util.List) call -->
    <property name="addressList">
        <list>
            <value>INDIA</value>
            <value>Pakistan</value>
        </list>
    </property>

    <!-- results in a setAddressSet(java.util.Set) call -->
    <property name="addressSet">
        <set>
            <value>INDIA</value>
            <value>Pakistan</value>
        </set>
    </property>

    <!-- results in a setAddressMap(java.util.Map) call -->
    <property name="addressMap">
        <map>
            <entry key="1" value="INDIA"/>
            <entry key="2" value="Pakistan"/>
        </map>
    </property>

    <!-- results in a setAddressProp(java.util.Properties) call -->
    <property name="addressProp">
        <props>
            <prop key="one">INDIA</prop>
            <prop key="two">Pakistan</prop>
        </props>
    </property>
</bean>

自动装配

你可以使用元素的 autowire 属性为一个 bean 定义指定自动装配模式。

模式	描述
no	这是默认的设置，它意味着没有自动装配，你应该使用显式的bean引用来连线。你不用为了连线做特殊的事。在依赖注入章节你已经看到这个了。
byName	由属性名自动装配。Spring 容器看到在 XML 配置文件中 bean 的自动装配的属性设置为 byName。然后尝试匹配，并且将它的属性与在配置文件中被定义为相同名称的 beans 的属性进行连接。
byType	由属性数据类型自动装配。Spring 容器看到在 XML 配置文件中 bean 的自动装配的属性设置为 byType。然后如果它的类型匹配配置文件中的一个确切的 bean 名称，它将尝试匹配和连接属性的类型。如果存在不止一个这样的 bean，则一个致命的异常将会被抛出。
constructor	类似于 byType，但该类型适用于构造函数参数类型。如果在容器中没有一个构造函数参数类型的 bean，则一个致命错误将会发生。
autodetect（3.0版本不支持）	Spring首先尝试通过 constructor 使用自动装配来连接，如果它不执行，Spring 尝试通过 byType 来自动装配。

主要注解

@Required：注解应用于 bean 属性的 setter 方法，它表明受影响的 bean 属性在配置时必须放在 XML 配置文件中，否则容器就会抛出一个 BeanInitializationException 异常。

public class Employee {
	private String name;
    
	@Required
	public void setName(String name){
		this.name=name;
	}
    
	public string getName(){
		return name;
	}
}

@Autowired和@Resource：

@Autowired自动装配指的就是使用将 Spring 容器中的 bean 自动的和我们需要这个 bean 的类组装在一起。以前那些是往Spring容器放bean，这个是取出来，默认byType，但经常会有一个类的多个实例，所以会冲突需要和@Qualifier配合使用，Qualifier就是限定的意思，相当于进一步按名字筛选

@Resource默认是byName查找，不过可以自定义byName还是byType，且并不是Spring框架的，它是Java原生的注解。

@Resource装配顺序：
①如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异
常。
②如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。
③如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常
④如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。@Resource的作用相当于@Autowired，只不过@Autowired按照byType自动注入

AOP

Spring 框架的一个关键组件是面向切面的编程(AOP)框架。面向切面的编程需要把程序逻辑分解成不同的部分称为所谓的关注点。作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为切面（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理

Aspect：切面，由一系列切点、增强和引入组成的模块对象，可定义优先级，从而影响增强和引入的执行顺序。事务管理（Transaction management）在java企业应用中就是一个很好的切面样例。所以他不是一个被代理的对象。

Join point：接入点，程序执行期的一个点，例如方法执行、类初始化、异常处理。 在Spring AOP中，接入点始终表示方法执行。

Advice：增强，切面在特定接入点的执行动作，包括 “around,” “before” and "after"等多种类型。包含Spring在内的许多AOP框架，通常会使用拦截器来实现增强，围绕着接入点维护着一个拦截器链。

Pointcut：切点，用来匹配特定接入点的谓词（表达式），增强将会与切点表达式产生关联，并运行在任何切点匹配到的接入点上。通过切点表达式匹配接入点是AOP的核心，Spring默认使用AspectJ的切点表达式。

Introduction：引入，为某个type声明额外的方法和字段。Spring AOP允许你引入任何接口以及它的默认实现到被增强对象上。

Target object：目标对象，被一个或多个切面增强的对象。也叫作被增强对象。既然Spring AOP使用运行时代理（runtime proxies），那么目标对象就总是代理对象。

AOP proxy：AOP代理，为了实现切面功能一个对象会被AOP框架创建出来。在Spring框架中AOP代理的默认方式是：有接口，就使用基于接口的JDK动态代理，否则使用基于类的CGLIB动态代理。但是我们可以通过设置proxy-target-class=“true”，完全使用CGLIB动态代理。

Weaving：织入，将一个或多个切面与类或对象链接在一起创建一个被增强对象。织入能发生在编译时 （compile time ）(使用AspectJ编译器)，加载时（load time），或运行时（runtime） 。Spring AOP默认就是运行时织入，可以通过枚举AdviceMode来设置。

在 OOP 中，关键单元模块度是类，而在 AOP 中单元模块度是切面。依赖注入帮助你对应用程序对象相互解耦合，AOP 可以帮助你从它们所影响的对象中对横切关注点解耦。

AOP实现的关键在于 代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态代理则以Spring AOP为代表。
（1）AspectJ是静态代理的增强，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，因此也称为编译时增强，他会在编译阶段将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。
（2）Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

项	描述
Aspect	一个模块具有一组提供横切需求的 APIs。例如，一个日志模块为了记录日志将被 AOP 方面调用。应用程序可以拥有任意数量的方面，这取决于需求。
Join point	在你的应用程序中它代表一个点，你可以在插件 AOP 方面。你也能说，它是在实际的应用程序中，其中一个操作将使用 Spring AOP 框架。
Advice	这是实际行动之前或之后执行的方法。这是在程序执行期间通过 Spring AOP 框架**实际被调用的代码。**
Pointcut	这是一组一个或多个连接点，通知应该被执行。你可以使用表达式或模式指定切入点正如我们将在 AOP 的例子中看到的。
Introduction	引用允许你添加新方法或属性到现有的类中。
Target object	被一个或者多个方面所通知的对象，这个对象永远是一个被代理对象。也称为被通知对象。
Weaving	Weaving 把方面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时，类加载时和运行时完成。

通知类型

通知	描述
前置通知 - before	在一个方法执行之前，执行通知。
后置通知 - after	在一个方法执行之后，不考虑其结果，执行通知。
返回后通知 - after returning	在一个方法执行之后，只有在方法成功完成时，才能执行通知。
抛出异常后通知 - after throwing	在一个方法执行之后，只有在方法退出抛出异常时，才能执行通知。
环绕通知 - around	在建议方法调用之前和之后，执行通知。

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" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

    <!-- bean注入 -->
    <bean id="aBean" class="...">
    ...
    </bean>
    
    <!-- aop设置 -->
    <aop:config>
        <aop:aspect id="myAspect" ref="aBean">
            <!-- 设置插入点，及目标类的某个方法,该切入点将
			与 com.tutorialspoint 包下的 Student 类中的 getName() 方法相匹配-->
            <aop:pointcut id="businessService"
                expression="execution(* com.tutorialspoint.Student.getName(..))"/>
            ...
            <!-- 前置通知 -->
            <aop:before pointcut-ref="businessService" 
                        method="doRequiredTask"/>
            <!-- 后置通知 -->
            <aop:after pointcut-ref="businessService" 
                       method="doRequiredTask"/>
            <!-- 返回后通知 -->
            <!--The doRequiredTask method must have parameter named retVal -->
            <aop:after-returning pointcut-ref="businessService" returning="retVal"
                                 method="doRequiredTask"/>
            <!-- 抛出异常后通知 -->
            <!--The doRequiredTask method must have parameter named ex -->
            <aop:after-throwing pointcut-ref="businessService" throwing="ex"
                                method="doRequiredTask"/>
            <!-- 环绕通知 -->
            <aop:around pointcut-ref="businessService" method="doRequiredTask"/>
        </aop:aspect>
    </aop:config>
</beans>

注解方式

定义Student类

package com.tutorialspoint;
public class Student {
    private Integer age;
    private String name;
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getAge() {
        System.out.println("Age : " + age );
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        System.out.println("Name : " + name );
        return name;
    }
    public void printThrowException(){
        System.out.println("Exception raised");
        throw new IllegalArgumentException();
    }
}

定义切入类

@Aspect
public class Logging {
	//定义切入点，后面那串就是指com.tutorialspoint包下的所有方法都被我承包了
    @Pointcut("execution(* com.tutorialspoint.*.*(..))")
    private void selectAll(){}

    @Before("selectAll()")
    public void beforeAdvice(){
        System.out.println("Going to setup student profile.");
    }

    @After("selectAll()")
    public void afterAdvice(){
        System.out.println("Student profile has been setup.");
    }

    @AfterReturning(pointcut = "selectAll()", returning="retVal")
    public void afterReturningAdvice(Object retVal){
        System.out.println("Returning:" + retVal.toString() );
    }

    @AfterThrowing(pointcut = "selectAll()", throwing = "ex")
    public void AfterThrowingAdvice(IllegalArgumentException ex){
        System.out.println("There has been an exception: " + ex.toString());   
    }  
}

xml文件配置

<!-- 开启代理 -->
<aop:aspectj-autoproxy/>

<!-- Definition for student bean -->
<bean id="student" class="com.tutorialspoint.Student">
    <property name="name"  value="Zara" />
    <property name="age"  value="11"/>      
</bean>

<!-- Definition for logging aspect -->
<bean id="logging" class="com.tutorialspoint.Logging"/> 

Spring MVC

MVC 框架提供了模型、视图、控制的体系结构和可以用来开发灵活、松散耦合的 web 应用程序的组件。MVC 模式导致了应用程序的不同方面(输入逻辑、业务逻辑和 UI 逻辑)的分离，同时提供了在这些元素之间的松散耦合。

• 模型 - Model ：封装了应用程序数据，并且通常它们由 POJO 组成。
• 视图 - View：主要用于呈现模型数据，并且通常它生成客户端的浏览器可以解释的 HTML 输出。
• 控制器 - Controller：主要用于处理用户请求，并且构建合适的模型并将其传递到视图呈现。

MVC处理流程

MVC框架是围绕 DispatcherServlet 设计的，DispatcherServlet 用来处理所有的 HTTP 请求和响应。

1. 向服务器发送 HTTP 请求，请求被前端控制器 DispatcherServlet 捕获。
2. DispatcherServlet 根据 servlet.xml 中的配置对请求的 URL 进行解析，得到请求资源标识符（URI）。然后根据该 URI，调用HandlerMapping获得该 Handler 配置的所有相关的对象（包括 Handler 对象以及 Handler 对象对应的拦截器），最后以 HandlerExecutionChain 对象的形式返回。
3. DispatcherServlet 根据获得的 Handler，选择一个合适的HandlerAdapter。（附注：如果成功获得 HandlerAdapter 后，此时将开始执行拦截器的 preHandler(…)方法）。
4. 提取 Request 中的模型数据，填充 Handler 入参，开始执行 Handler(Controller)。在填充 Handler 的入参过程中，根据你的配置，Spring 将帮你做一些额外的工作：
   • HttpMessageConveter：将请求消息（如 Json、xml 等数据）转换成一个对象，将对象转换为指定的响应信息。
   • 数据转换：对请求消息进行数据转换。如 String 转换成 Integer、Double 等。
   • 数据根式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等。
   • 数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult 或 Error 中。
5. Handler(Controller)执行完成后，向 DispatcherServlet 返回一个ModelAndView 对象
6. 根据返回的 ModelAndView，选择一个适合的 ViewResolver（必须是已经注册到 Spring 容器中的 ViewResolver)返回给DispatcherServlet。
7. ViewResolver 结合 Model 和 View，来渲染视图。
8. 视图负责将渲染结果返回给客户端。

常用注解：

注解	功能描述
@Controller	组合注解（组合了@Component注解），应用在MVC层（控制层）,DispatcherServlet会自动扫描注解了此注解的类，然后将web请求映射到注解了@RequestMapping的方法上。
@Service	组合注解（组合了@Component注解），应用在service层（业务逻辑层）
@Reponsitory	组合注解（组合了@Component注解），应用在dao层（数据访问层）
@Component	表示一个带注释的类是一个“组件”，成为Spring管理的Bean。当使用基于注解的配置和类路径扫描时，这些类被视为自动检测的候选对象。同时@Component还是一个元注解。
@Autowired	Spring提供的工具（由Spring的依赖注入工具（BeanPostProcessor、BeanFactoryPostProcessor）自动注入。）
@Resource	JSR-250提供的注解
@Inject	JSR-330提供的注解
@Configuration	声明当前类是一个配置类（相当于一个Spring配置的xml文件）
@ComponentScan	自动扫描指定包下所有使用@Service,@Component,@Controller,@Repository的类并注册
@Bean	注解在方法上，声明当前方法的返回值为一个Bean。返回的Bean对应的类中可以定义init()方法和destroy()方法，然后在@Bean(initMethod=”init”,destroyMethod=”destroy”)定义，在构造之后执行init，在销毁之前执行destroy。
@Aspect	声明一个切面（就是说这是一个额外功能）
@After	后置建言（advice），在原方法前执行。
@Before	前置建言（advice），在原方法后执行。
@Around	环绕建言（advice），在原方法执行前执行，在原方法执行后再执行（@Around可以实现其他两种advice）
@PointCut	声明切点，即定义拦截规则，确定有哪些方***被切入
@Transactional	声明事务（一般默认配置即可满足要求，当然也可以自定义）
@Cacheable	声明数据缓存
@EnableAspectJ***	开启Spring对AspectJ的支持
@Value	值得注入。经常与Sping EL表达式语言一起使用，注入普通字符，系统属性，表达式运算结果，其他Bean的属性，文件内容，网址请求内容，配置文件属性值等等
@PropertySource	指定文件地址。提供了一种方便的、声明性的机制，用于向Spring的环境添加PropertySource。与@configuration类一起使用。
@PostConstruct	标注在方法上，该方法在构造函数执行完成之后执行。
@PreDestroy	标注在方法上，该方法在对象销毁之前执行。
@Profile	表示当一个或多个指定的文件是活动的时，一个组件是有资格注册的。使用@Profile注解类或者方法，达到在不同情况下选择实例化不同的Bean。@Profile(“dev”)表示为dev时实例化。
@EnableAsync	开启异步任务支持。注解在配置类上。
@Async	注解在方法上标示这是一个异步方法，在类上标示这个类所有的方法都是异步方法。
@EnableScheduling	注解在配置类上，开启对计划任务的支持。
@Scheduled	注解在方法上，声明该方法是计划任务。支持多种类型的计划任务：cron,fixDelay,fixRate
@Conditional	根据满足某一特定条件创建特定的Bean
@Enable*	通过简单的@Enable来开启一项功能的支持。所有@Enable注解都有一个@Import注解，@Import是用来导入配置类的，这也就意味着这些自动开启的实现其实是导入了一些自动配置的Bean(1.直接导入配置类2.依据条件选择配置类3.动态注册配置类)
@RunWith	这个是Junit的注解，springboot集成了junit。一般在测试类里使用:@RunWith(SpringJUnit4ClassRunner.class) — SpringJUnit4ClassRunner在JUnit环境下提供Sprng TestContext Framework的功能
@ContextConfiguration	用来加载配置ApplicationContext，其中classes属性用来加载配置类:@ContextConfiguration(classes = {TestConfig.class(自定义的一个配置类)})
@ActiveProfiles	用来声明活动的profile–@ActiveProfiles(“prod”(这个prod定义在配置类中))
@EnableWebMvc	用在配置类上，开启SpringMvc的Mvc的一些默认配置：如ViewResolver，MessageConverter等。同时在自己定制SpringMvc的相关配置时需要做到两点：1.配置类继承WebMvcConfigurerAdapter类2.就是必须使用这个@EnableWebMvc注解。
@RequestMapping	用来映射web请求（访问路径和参数），处理类和方法的。可以注解在类和方法上，注解在方法上的@RequestMapping路径会继承注解在类上的路径。同时支持Serlvet的request和response作为参数，也支持对request和response的媒体类型进行配置。其中有value(路径)，produces(定义返回的媒体类型和字符集)，method(指定请求方式)等属性。
@ResponseBody	将返回值放在response体内。返回的是数据而不是页面
@RequestBody	允许request的参数在request体中，而不是在直接链接在地址的后面。此注解放置在参数前。
@PathVariable	放置在参数前，用来接受路径参数。
@RestController	组合注解，组合了@Controller和@ResponseBody,当我们只开发一个和页面交互数据的控制层的时候可以使用此注解。
@ControllerAdvice	用在类上，声明一个控制器建言，它也组合了@Component注解，会自动注册为Spring的Bean。
@ExceptionHandler	用在方法上定义全局处理，通过他的value属性可以过滤拦截的条件：@ExceptionHandler(value=Exception.class)–表示拦截所有的Exception。
@ModelAttribute	将键值对添加到全局，所有注解了@RequestMapping的方法可获得次键值对（就是在请求到达之前，往model里addAttribute一对name-value而已）。
@InitBinder	通过@InitBinder注解定制WebDataBinder（用在方法上，方法有一个WebDataBinder作为参数，用WebDataBinder在方法内定制数据绑定，例如可以忽略request传过来的参数Id等）。
@WebAppConfiguration	一般用在测试上，注解在类上，用来声明加载的ApplicationContext是一个WebApplicationContext。他的属性指定的是Web资源的位置，默认为src/main/webapp,我们可以修改为：@WebAppConfiguration(“src/main/resources”)。
@EnableAutoConfiguration	此注释自动载入应用程序所需的所有Bean——这依赖于Spring Boot在类路径中的查找。该注解组合了@Import注解，@Import注解导入了EnableAutoCofigurationImportSelector类，它使用SpringFactoriesLoader.loaderFactoryNames方法来扫描具有META-INF/spring.factories文件的jar包。而spring.factories里声明了有哪些自动配置。
@SpingBootApplication	SpringBoot的核心注解，主要目的是开启自动配置。它也是一个组合注解，主要组合了@Configurer，@EnableAutoConfiguration（核心）和@ComponentScan。可以通过@SpringBootApplication(exclude={想要关闭的自动配置的类名.class})来关闭特定的自动配置。
@ImportResource	虽然Spring提倡零配置，但是还是提供了对xml文件的支持，这个注解就是用来加载xml配置的。例：@ImportResource({“classpath
@ConfigurationProperties	将properties属性与一个Bean及其属性相关联，从而实现类型安全的配置。例：@ConfigurationProperties(prefix=”authot”，locations={“classpath
@ConditionalOnBean	条件注解。当容器里有指定Bean的条件下。
@ConditionalOnClass	条件注解。当类路径下有指定的类的条件下。
@ConditionalOnExpression	条件注解。基于SpEL表达式作为判断条件。
@ConditionalOnJava	条件注解。基于JVM版本作为判断条件。
@ConditionalOnJndi	条件注解。在JNDI存在的条件下查找指定的位置。
@ConditionalOnMissingBean	条件注解。当容器里没有指定Bean的情况下。
@ConditionalOnMissingClass	条件注解。当类路径下没有指定的类的情况下。
@ConditionalOnNotWebApplication	条件注解。当前项目不是web项目的条件下。
@ConditionalOnResource	条件注解。类路径是否有指定的值。
@ConditionalOnSingleCandidate	条件注解。当指定Bean在容器中只有一个，后者虽然有多个但是指定首选的Bean。
@ConditionalOnWebApplication	条件注解。当前项目是web项目的情况下。
@EnableConfigurationProperties	注解在类上，声明开启属性注入，使用@Autowired注入。例：@EnableConfigurationProperties(HttpEncodingProperties.class)。
@AutoConfigureAfter	在指定的自动配置类之后再配置。例：@AutoConfigureAfter(WebMvcAutoConfiguration.class)

Spring事务管理的两种方式

spring支持编程式事务管理和声明式事务管理两种方式。

• 编程式事务使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。
• 声明式事务是建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于**@Transactional**注解的方式)，便可以将事务规则应用到业务逻辑中。

显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，它的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。

声明式事务管理也有两种常用的方式，一种是基于tx和aop名字空间的xml配置文件，另一种就是基于@Transactional注解。显然基于注解的方式更简单易用，更清爽。

事务的隔离级别

隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：

1、ISOLATION_DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。

2、ISOLATION_READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读，不可重复读和幻读，因此很少使用该隔离级别。比如PostgreSQL实际上并没有此级别。

3、ISOLATION_READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。

4、ISOLATION_REPEATABLE_READ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。该级别可以防止脏读和不可重复读。

5、ISOLATION_SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

事务传播行为

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量：

1、PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。

2、PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。

3、PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

4、PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

5、PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

6、PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

7、PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。