Spring框架系列相关面试问题

1.说说你了解的spring中的设计模式

第一种：简单工厂

又叫做静态工厂方法（staticfactory method）模式，但不属于23种gof设计模式之一。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

spring中的beanfactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。如下配置，就是在 helloitxxz 类中创建一个 itxxzbean。

<code><</code><code>beans</code><code>></code>

<code> </code><code><</code><code>bean</code> <code>id="singletonbean" class="com.itxxz.helloitxxz"></code>

<code> </code><code><</code><code>constructor-arg</code><code>></code>

<code> </code><code><</code><code>value</code><code>>hello! 这是singletonbean!value></code>

<code> </code><code></</code><code>constructor-arg</code><code>></code>

<code> </code><code><</code><code>bean</code> <code>id="itxxzbean" class="com.itxxz.helloitxxz"</code>

<code> </code><code>singleton="false"></code>

<code> </code><code><</code><code>value</code><code>>hello! 这是itxxzbean! value></code>

<code></</code><code>beans</code><code>></code>

第二种：工厂方法（factory method）

通常由应用程序直接使用new创建新的对象，为了将对象的创建和使用相分离，采用工厂模式,即应用程序将对象的创建及初始化职责交给工厂对象。

一般情况下,应用程序有自己的工厂对象来创建bean.如果将应用程序自己的工厂对象交给spring管理,那么spring管理的就不是普通的bean,而是工厂bean。

<code>import</code> <code>java.util.random;</code>

<code>public</code> <code>class</code> <code>staticfactorybean {</code>

<code> </code><code>public</code> <code>static</code> <code>integer createrandom() {</code>

<code> </code><code>return</code> <code>new</code> <code>integer(</code><code>new</code> <code>random().nextint());</code>

建一个config.xm配置文件，将其纳入spring容器来管理,需要通过factory-method指定静态方法名称

<code><</code><code>bean</code> <code>id="random"</code>

<code>class="example.chapter3.staticfactorybean" factory-method="createrandom" //createrandom方法必须是static的,才能找到 scope="prototype"</code>

测试:

<code>public</code> <code>static</code> <code>void</code> <code>main(string[] args) {</code>

<code> </code><code>//调用getbean()时,返回随机数.如果没有指定factory-method,会返回staticfactorybean的实例,即返回工厂bean的实例 xmlbeanfactory factory = new xmlbeanfactory(new classpathresource("config.xml")); system.out.println("我是it学习者创建的实例:"+factory.getbean("random").tostring());</code>

第三种：单例模式（singleton）

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

spring中的单例模式完成了后半句话，即提供了全局的访问点beanfactory。但没有从构造器级别去控制单例，这是因为spring管理的是是任意的java对象。

核心提示点：spring下默认的bean均为singleton，可以通过singleton=“true|false” 或者 scope=“？”来指定。

第四种：适配器（adapter）

在spring的aop中，使用的advice（通知）来增强被代理类的功能。spring实现这一aop功能的原理就使用代理模式（1、jdk动态代理。2、cglib字节码生成技术代理。）对类进行方法级别的切面增强，即，生成被代理类的代理类，并在代理类的方法前，设置拦截器，通过执行拦截器重的内容增强了代理方法的功能，实现的面向切面编程。

adapter类接口：target

<code>public</code> <code>interface</code> <code>advisoradapter {</code>

<code>boolean</code> <code>supportsadvice(advice advice);</code>

<code> </code><code>methodinterceptor getinterceptor(advisor advisor);</code>

methodbeforeadviceadapter类，adapter

<code>class</code> <code>methodbeforeadviceadapter </code><code>implements</code> <code>advisoradapter, serializable {</code>

<code> </code><code>public</code> <code>boolean</code> <code>supportsadvice(advice advice) {</code>

<code> </code><code>return</code> <code>(advice </code><code>instanceof</code> <code>methodbeforeadvice);</code>

<code> </code><code>public</code> <code>methodinterceptor getinterceptor(advisor advisor) {</code>

<code> </code><code>methodbeforeadvice advice = (methodbeforeadvice) advisor.getadvice();</code>

<code> </code><code>return</code> <code>new</code> <code>methodbeforeadviceinterceptor(advice);</code>

第五种：包装器（decorator）

在我们的项目中遇到这样一个问题：我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。我们以往在spring和hibernate框架中总是配置一个数据源，因而sessionfactory的datasource属性总是指向这个数据源并且恒定不变，所有dao在使用sessionfactory的时候都是通过这个数据源访问数据库。但是现在，由于项目的需要，我们的dao在访问sessionfactory的时候都不得不在多个数据源中不断切换，问题就出现了：如何让sessionfactory在执行数据持久化的时候，根据客户的需求能够动态切换不同的数据源？我们能不能在spring的框架下通过少量修改得到解决？是否有什么设计模式可以利用呢？

首先想到在spring的applicationcontext中配置所有的datasource。这些datasource可能是各种不同类型的，比如不同的数据库：oracle、sql server、mysql等，也可能是不同的数据源：比如apache 提供的org.apache.commons.dbcp.basicdatasource、spring提供的org.springframework.jndi.jndiobjectfactorybean等。然后sessionfactory根据客户的每次请求，将datasource属性设置成不同的数据源，以到达切换数据源的目的。

spring中用到的包装器模式在类名上有两种表现：一种是类名中含有wrapper，另一种是类名中含有decorator。基本上都是动态地给一个对象添加一些额外的职责。

第六种：代理（proxy）

为其他对象提供一种代理以控制对这个对象的访问。从结构上来看和decorator模式类似，但proxy是控制，更像是一种对功能的限制，而decorator是增加职责。

spring的proxy模式在aop中有体现，比如jdkdynamicaopproxy和cglib2aopproxy。

第七种：观察者（observer）

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

spring中observer模式常用的地方是listener的实现。如applicationlistener。

第八种：策略（strategy）

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

spring中在实例化对象的时候用到strategy模式

在simpleinstantiationstrategy中有如下代码说明了策略模式的使用情况：

第九种：模板方法（template method）

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。template method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

template method模式一般是需要继承的。这里想要探讨另一种对template method的理解。spring中的jdbctemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到jdbctemplate已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入jdbctemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到jdbctemplate中的变量。怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵jdbctemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到jdbctemplate，从而完成了调用。这可能是template method不需要继承的另一种实现方式吧。

以下是一个具体的例子：

jdbctemplate中的execute方法

jdbctemplate执行execute方法

4.spring中bean的作用域有哪些及之间的区别

5.spring工作机制及为什么要用？

spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。spring既是一个aop框架，也是一ioc容器。

springframework的组成：spring aop，spring dao，spring orm，spring web，spring context， spring web mvc。

spring的核心就是ioc和aop，所以spring的工作机制简单的理解也就是ioc和aop的工作机制。

借助于spring aop，spring ioc能够很方便的使用到非常健壮、灵活的企业级服务，通过使用ioc能够降低组件之间的耦合度，最终，能够提高类的重用性，利于测试，而且更利于整个产品或系统集成和配置。

6.说说aop和ioc的概念以及在spring中是如何应用的?

aop，aspect oriented program，面向(方面)切面的编程；

ioc，invert of control，控制反转。

简单说一下，ioc就是其实就是依赖注入，即用接口编程，在程序中不出现new关键字，而是用接口来命名引用，然后通过某种方式把接口的某个实现类的实例注入到引用里，从而实现接口与具体实现类的松耦合。

由容器控制程序之间的关系(通过xml配置)，而非传统实现中的由程序代码直接操控，(在一个class对象中引用另一个class对象时，我们通常都是直接通过new contructor)。控制权由应用代码中转到了外部容器，控制权的转移，是所谓的反转。

aop方式很类似filter，就是在程序正常的业务流中间像切面一样插入很多其他需要执行的代码，比如登录时候，在进入登录页面前写入日志，很常用的，尤其是跟数据库有关的，或者跟支付有关的程序肯定会在每一步前面插入日志。

面向方面的编程，即 aop，是一种编程技术，它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。aop 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。

aop advice（aop通知）分为：

前置通知后置通知异常通知环绕通知

7.spring的事物有几种方式？谈谈spring事物的隔离级别和传播行为？

声明式事务使用spring声明式事务，spring使用aop来支持声明式事务，会根据事务属性，自动在方法调用之前决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。

事务的隔离级别：

数据库系统提供了4种事务隔离级别，在这4种隔离级别中，serializable的隔离级别最高，read uncommitted的隔离级别最低；

<code>read uncommitted 读未提交数据；（会出现脏读）</code>

<code>read committed 读已提交数据；</code>

<code>repeatable read 可重复读；</code>

<code>serializable 串行化</code>

事务的传播属性包括：

required 业务方法需要在一个事务中运行，如果一个方法运行时已经处在一个事务中，那么加入到该事务，否则为自己创建一个新事务，80%的方法用到该传播属性；

not-supported· requiresnew· mandatoky· supports· never· nested

8.spring mvc工作原理：

1.spring mvc请所有的请求都提交给dispatcherservlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。

2.dispatcherservlet查询一个或多个handlermapping,找到处理请求的controller.

3.dispatcherservlet请请求提交到目标controller

4.controller进行业务逻辑处理后，会返回一个modelandview

5.dispathcher查询一个或多个viewresolver视图解析器,找到modelandview对象指定的视图对象

6.视图对象负责渲染返回给客户端。

9.spring里面如何配置数据库驱动？

使用”org.springframework.jdbc.datasource.drivermanagerdatasource”数据源来配置数据库驱动。示例如下：

<code><</code><code>bean</code> <code>id=”datasource”></code>

<code><</code><code>property</code> <code>name=”driverclassname”></code>

<code><</code><code>value</code><code>>org.hsqldb.jdbcdriver</</code><code>value</code><code>></code>

<code></</code><code>property</code><code>></code>

<code><</code><code>property</code> <code>name=”url”></code>

<code><</code><code>value</code><code>>jdbc:hsqldb:db/appfuse</</code><code>value</code><code>></code>

<code><</code><code>property</code> <code>name=”username”><</code><code>value</code><code>>sa</</code><code>value</code><code>></</code><code>property</code><code>></code>

<code><</code><code>property</code> <code>name=”password”><</code><code>value</code><code>></</code><code>value</code><code>></</code><code>property</code><code>></code>

10.spring里面applicationcontext.xml文件能不能改成其他文件名？

contextloaderlistener是一个servletcontextlistener, 它在你的web应用启动的时候初始化。缺省情况下，它会在web-inf/applicationcontext.xml文件找spring的配置。你可以通过定义一个<context-param>元素名字为”contextconfiglocation”来改变spring配置文件的位置。示例如下：

<code><</code><code>listener</code><code>></code>

<code><</code><code>listener-class</code><code>>org.springframework.web.context.contextloaderlistener <</code><code>context-param</code><code>></code>

<code><</code><code>param-name</code><code>>contextconfiglocation</</code><code>param-name</code><code>></code>

<code><</code><code>param-value</code><code>>/web-inf/xyz.xml</</code><code>param-value</code><code>></code>

<code></</code><code>context-param</code><code>> </</code><code>listener-class</code><code>></code>

<code></</code><code>listener</code><code>></code>

11.如何在web应用里面配置spring?

在web.xml中加入如下同容,在启动web服务器时加载/web-inf/applicationcontext.xml中的内容。

<code><</code><code>servlet</code><code>></code>

<code><</code><code>servlet-name</code><code>>context</</code><code>servlet-name</code><code>></code>

<code><</code><code>servlet-class</code><code>></code>

<code>org.springframework.web.context.contextloaderservlet</code>

<code></</code><code>servlet-class</code><code>></code>

<code><</code><code>load-on-startup</code><code>>1</</code><code>load-on-startup</code><code>></code>

<code></</code><code>servlet</code><code>></code>

通过如下类得到applicationcontext实例

<code>webapplicationcontextutils.getwebapplicationcontext</code>

12.spring里面如何定义hibernate mapping？

添加hibernate mapping 文件到web/web-inf目录下的applicationcontext.xml文件里面。示例如下：

<code><</code><code>property</code> <code>name=”mappingresources”></code>

<code><</code><code>value</code><code>>org/appfuse/model/user.hbm.xml</</code><code>value</code><code>></code>

13.解释一下dependency injection(di,依赖注入)和ioc(inversion of control,控制反转)?

依赖注入di是一个程序设计模式和架构模型，一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个ioc的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖

应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

14.spring中的beanfactory与applicationcontext的作用有哪些？

1. beanfactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。

2. applicationcontext除了提供上述beanfactory所能提供的功能之外，还提供了更完整的框架功能：

a. 国际化支持

b. 资源访问：resource rs = ctx. getresource(”classpath:config.properties”), “file:c:/config.properties”

c. 事件传递：通过实现applicationcontextaware接口

3. 常用的获取applicationcontext的方法：

filesystemxmlapplicationcontext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组

classpathxmlapplicationcontext：从classpath的xml配置文件创建，可以从jar包中读取配置文件

webapplicationcontextutils：从web应用的根目录读取配置文件，需要先在web.xml中配置，可以配置监听器或者servlet来实现

<code><</code><code>listener-class</code><code>>org.springframework.web.context.contextloaderlistener</</code><code>listener-class</code><code>></code>

<code><</code><code>servlet-class</code><code>>org.springframework.web.context.contextloaderservlet</</code><code>servlet-class</code><code>></code>

这两种方式都默认配置文件为web-inf/applicationcontext.xml，也可使用context-param指定配置文件

<code><</code><code>context-param</code><code>></code>

<code><</code><code>param-value</code><code>>/web-inf/myapplicationcontext.xml</</code><code>param-value</code><code>></code>

<code></</code><code>context-param</code><code>></code>

15.如何在web环境中配置applicationcontext.xml文件?

<code><</code><code>listener-class</code><code>></code>

<code>org.springframework.web.context.contextloaderlistener</code>

<code></</code><code>listener-class</code><code>></code>

或：

通过如下方法取出applicationcontext实例:

applicationcontext ac=webapplicationcontextutils.getwebapplicationcontext(this.getservletcontext);

16.spring+hibernate的配置文件中的主要类有那些?如何配置?

<code>datasource</code>

<code>sessionfactory:hibernate.cfg.xml</code>

<code>transactionmanager</code>

<code>userdao (extends hibernatedaosupport)</code>

<code>sessionfactory</code>

<code>facade</code>

<code>proxy</code>

17.如何在spring中实现国际化?

在applicationcontext.xml加载一个bean

<code><</code><code>bean</code> <code>id=”messagesource” class=”org.springframework.context.support.resourcebundlemessagesource”></code>

<code><</code><code>property</code> <code>name=”basename”></code>

<code><</code><code>value</code><code>>message</</code><code>value</code><code>></code>

在src目录下建多个properties文件

对于非英文的要用native2ascii -encoding gb2312 源目转化文件相关内容

其命名格式是message_语言_国家。

页面中的中显示提示信息，键名取键值。

当给定国家，系统会自动加载对应的国家的properties信息。

通过applictioncontext.getmessage(“键名”,”参数”,”区域”)取出相关的信息。

18.spring中的核心类有那些，各有什么作用?

beanfactory：产生一个新的实例，可以实现单例模式

beanwrapper：提供统一的get及set方法

applicationcontext:提供框架的实现，包括beanfactory的所有功能

19.什么是aop，aop的作用是什么?

面向切面编程（aop）提供另外一种角度来思考程序结构，通过这种方式弥补了面向对象编程（oop）的不足

除了类（classes）以外，aop提供了切面。切面对关注点进行模块化，例如横切多个类型和对象的事务管理

spring的一个关键的组件就是aop框架，可以自由选择是否使用aop

提供声明式企业服务，特别是为了替代ejb声明式服务。最重要的服务是声明性事务管理，这个服务建立在spring的抽象事物管理之上

允许用户实现自定义切面，用aop来完善oop的使用

可以把spring aop看作是对spring的一种增强

20.请介绍一下spring框架中bean的生命周期

一、bean的定义

spring通常通过配置文件定义bean。如：

<code><?</code><code>xml</code> <code>version=”1.0″ encoding=”utf-8″?></code>

<code><</code><code>bean</code> <code>id=”helloworld” class=”com.pqf.beans.helloworld”></code>

<code><</code><code>property</code> <code>name=”msg”></code>

<code><</code><code>value</code><code>>helloworld</</code><code>value</code><code>></code>

这个配置文件就定义了一个标识为 helloworld 的bean。在一个配置文档中可以定义多个bean。

二、bean的初始化

有两种方式初始化bean。

1、在配置文档中通过指定init-method 属性来完成

在bean的类中实现一个初始化bean属性的方法，如init()，如：

<code>public</code> <code>class</code> <code>helloworld{</code>

<code>public</code> <code>string msg=</code><code>null</code><code>;</code>

<code>public</code> <code>date date=</code><code>null</code><code>;</code>

<code>public</code> <code>void</code> <code>init() {</code>

<code>msg=”helloworld”;</code>

然后，在配置文件中设置init-mothod属性：

<code><</code><code>bean</code> <code>id=”helloworld” class=”com.pqf.beans.helloworld”init-mothod=”init” ></code>

2、实现 org.springframwork.beans.factory.initializingbean接口

bean实现initializingbean接口，并且增加 afterpropertiesset() 方法：

<code>public</code> <code>class</code> <code>helloworld implement initializingbean {</code>

<code>public</code> <code>void</code> <code>afterpropertiesset() {</code>

<code>msg=”向全世界问好！”;</code>

那么，当这个bean的所有属性被spring的beanfactory设置完后，会自动调用afterpropertiesset()方法对bean进行初始化，于是，配置文件就不用指定 init-method属性了。

三、bean的调用

有三种方式可以得到bean并进行调用：

1、使用beanwrapper

<code>helloworld hw=</code><code>new</code> <code>helloworld();</code>

<code>beanwrapper bw=</code><code>new</code> <code>beanwrapperimpl(hw);</code>

<code>bw.setpropertyvalue(”msg”,”helloworld”);</code>

<code>system.out.println(bw.getpropertycalue(”msg”)); <em id=</code><code>"__mcedel"</code> <code>style=</code><code>"font-family: verdana, arial, helvetica, sans-serif; font-size: 14px; line-height: 1.5; background-color: #ffffff;"</code><code>>　</em></code>

2、使用beanfactory

<code>inputstream is=</code><code>new</code> <code>fileinputstream(”config.xml”);</code>

<code>xmlbeanfactory factory=</code><code>new</code> <code>xmlbeanfactory(is);</code>

<code>helloworld hw=(helloworld) factory.getbean(”helloworld”);</code>

<code>system.out.println(hw.getmsg()); <em id=</code><code>"__mcedel"</code> <code>style=</code><code>"font-family: verdana, arial, helvetica, sans-serif; font-size: 14px; line-height: 1.5; background-color: #ffffff;"</code><code>>　</em></code>

3、使用applicationconttext

<code>applicationcontext actx=</code><code>new</code> <code>flesystemxmlapplicationcontext(”config.xml”);</code>

<code>helloworld hw=(helloworld) actx.getbean(”helloworld”);</code>

<code>system.out.println(hw.getmsg());</code>

四、bean的销毁

1、使用配置文件中的 destory-method 属性

与初始化属性 init-methods类似，在bean的类中实现一个撤销bean的方法，然后在配置文件中通过 destory-method指定，那么当bean销毁时，spring将自动调用指定的销毁方法。

2、实现 org.springframwork.bean.factory.disposeblebean接口

如果实现了disposeblebean接口，那么spring将自动调用bean中的destory方法进行销毁，所以，bean中必须提供destory方法。

21.aop里面重要的几个名词概念解释：

切面（aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是j2ee应用中一个关于横切关注点的很好的例子。在spring aop中，切面可以使用通用类（基于模式的风格）或者在普通类中以 @aspect 注解（@aspectj风格）来实现。

连接点（joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在spring aop中，一个连接点总是代表一个方法的执行。通过声明一个org.aspectj.lang.joinpoint类型的参数可以使通知（advice）的主体部分获得连接点信息。

通知（advice）：在切面的某个特定的连接点（joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。通知的类型将在后面部分进行讨论。许多aop框架，包括spring，都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

切入点（pointcut）：匹配连接点（joinpoint）的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是aop的核心：spring缺省使用aspectj切入点语法。

引入（introduction）：（也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。 spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用一个引入来使bean实现 ismodified 接口，以便简化缓存机制。

目标对象（target object）：被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做被通知（advised）对象。既然spring aop是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。

aop代理（aop proxy）： aop框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。在spring中，aop代理可以是jdk动态代理或者cglib代理。注意：spring 2.0最新引入的基于模式（schema-based）风格和@aspectj注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。

织入（weaving）：把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。这些可以在编译时（例如使用aspectj编译器），类加载时和运行时完成。 spring和其他纯java aop框架一样，在运行时完成织入。

通知的类型：

前置通知（before advice）：在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。

返回后通知（after returning advice）：在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。

抛出异常后通知（after throwing advice）：在方法抛出异常退出时执行的通知。

后通知（after (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。

环绕通知（around advice）：包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

环绕通知是最常用的一种通知类型。大部分基于拦截的aop框架，例如nanning和jboss4，都只提供环绕通知。

切入点（pointcut）和连接点（join point）匹配的概念是aop的关键，这使得aop不同于其它仅仅提供拦截功能的旧技术。切入点使得定位通知（advice）可独立于oo层次。例如，一个提供声明式事务管理的around通知可以被应用到一组横跨多个对象中的方法上（例如服务层的所有业务操作）。

22.spring的事务管理机制

spring事务机制主要包括声明式事务和编程式事务，此处侧重讲解声明式事务，编程式事务在实际开发中得不到广泛使用，仅供学习参考。

spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理大量的try…catch…finally代码。我们在使用spring声明式事务时，有一个非常重要的概念就是事务属性。事务属性通常由事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划分时，需要进行事务定义，也就是配置事务的属性。

下面分别详细讲解，事务的四种属性，仅供诸位学习参考：

spring在transactiondefinition接口中定义这些属性,以供platfromtransactionmanager使用, platfromtransactionmanager是spring事务管理的核心接口。

<code>public</code> <code>interface</code> <code>transactiondefinition {</code>

<code>int</code> <code>getpropagationbehavior();</code><code>//返回事务的传播行为。</code>

<code>int</code> <code>getisolationlevel();</code><code>//返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。</code>

<code>int</code> <code>gettimeout();</code><code>//返回事务必须在多少秒内完成。</code>

<code>boolean</code> <code>isreadonly();</code><code>//事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的。</code>

1. transactiondefinition接口中定义五个隔离级别：

<code>isolation_default 这是一个platfromtransactionmanager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与jdbc的隔离级别相对应；</code>

<code>isolation_read_uncommitted 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。</code>

<code>isolation_read_committed 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。</code>

<code>isolation_repeatable_read 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。</code>

<code>isolation_serializable 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。</code>

1： dirty reads（脏读）。也就是说，比如事务a的未提交（还依然缓存）的数据被事务b读走，如果事务a失败回滚，会导致事务b所读取的的数据是错误的。

2： non-repeatable reads（数据不可重复读）。比如事务a中两处读取数据-total-的值。在第一读的时候，total是100，然后事务b就把total的数据改成200，事务a再读一次，结果就发现，total竟然就变成200了，造成事务a数据混乱。

3： phantom reads（幻象读数据），这个和non-repeatable reads相似，也是同一个事务中多次读不一致的问题。但是non-repeatable reads的不一致是因为他所要取的数据集被改变了（比如total的数据），但是phantom reads所要读的数据的不一致却不是他所要读的数据集改变，而是他的条件数据集改变。比如select account.id where account.name="ppgogo*",第一次读去了6个符合条件的id，第二次读取的时候，由于事务b把一个帐号的名字由"dd"改成"ppgogo1"，结果取出来了7个数据。

2. 在transactiondefinition接口中定义了七个事务传播行为：

（1）propagation_required 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。

<code>//事务属性 propagation_required</code>

<code>methoda{</code>

<code>methodb();</code>

<code>methodb{</code>

使用spring声明式事务，spring使用aop来支持声明式事务，会根据事务属性，自动在方法调用之前决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。

单独调用methodb方法：

<code>metodb();</code>

相当于

<code>connection con=</code><code>null</code><code>;</code>

<code>con = getconnection();</code>

<code>con.setautocommit(</code><code>false</code><code>);</code>

<code>con.commit();</code>

<code>catch(runtimeexception ex){</code>

<code>con.rollback();</code>

<code>finally</code><code>{</code>

<code>closecon();</code>

spring保证在methodb方法中所有的调用都获得到一个相同的连接。在调用methodb时，没有一个存在的事务，所以获得一个新的连接，开启了一个新的事务。

单独调用methoda时，在methoda内又会调用methodb.

执行效果相当于：

<code>connection con = </code><code>null</code><code>;</code>

<code>methoda();</code>

<code>catch</code><code>(runtimeexception ex){</code>

调用methoda时，环境中没有事务，所以开启一个新的事务.当在methoda中调用methodb时，环境中已经有了一个事务，所以methodb就加入当前事务。

（2）propagation_supports 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，propagation_supports与不使用事务有少许不同。

<code>methoda(){</code>

<code>//事务属性 propagation_supports</code>

<code>methodb(){</code>

单纯的调用methodb时，methodb方法是非事务的执行的。当调用methda时,methodb则加入了methoda的事务中,事务地执行。

（3）propagation_mandatory 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

<code>//事务属性 propagation_mandatory</code>

当单独调用methodb时，因为当前没有一个活动的事务，则会抛出异常throw new illegaltransactionstateexception("transaction propagation 'mandatory' but no existing transaction found");当调用methoda时，methodb则加入到methoda的事务中，事务地执行。

（4）propagation_requires_new 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

<code>dosomethinga();</code>

<code>dosomethingb();</code>

<code>//事务属性 propagation_requires_new</code>

<code>java代码：</code>

<code>transactionmanager tm = </code><code>null</code><code>;</code>

<code>//获得一个jta事务管理器</code>

<code>tm = gettransactionmanager();</code>

<code>tm.begin();</code><code>//开启一个新的事务</code>

<code>transaction ts1 = tm.gettransaction();</code>

<code>dosomething();</code>

<code>tm.suspend();</code><code>//挂起当前事务</code>

<code>tm.begin();</code><code>//重新开启第二个事务</code>

<code>transaction ts2 = tm.gettransaction();</code>

<code>ts2.commit();</code><code>//提交第二个事务</code>

<code>ts2.rollback();</code><code>//回滚第二个事务</code>

<code>//methodb执行完后，复恢第一个事务</code>

<code>tm.resume(ts1);</code>

<code>ts1.commit();</code><code>//提交第一个事务</code>

<code>ts1.rollback();</code><code>//回滚第一个事务</code>

在这里，我把ts1称为外层事务，ts2称为内层事务。从上面的代码可以看出，ts2与ts1是两个独立的事务，互不相干。ts2是否成功并不依赖于ts1。如果methoda方法在调用methodb方法后的dosomethingb方法失败了，而methodb方法所做的结果依然被提交。而除了methodb之外的其它代码导致的结果却被回滚了。使用propagation_requires_new,需要使用jtatransactionmanager作为事务管理器。

（5）propagation_not_supported 总是非事务地执行，并挂起任何存在的事务。使用propagation_not_supported,也需要使用jtatransactionmanager作为事务管理器。（代码示例同上，可同理推出）

（6）propagation_never 总是非事务地执行，如果存在一个活动事务，则抛出异常；

（7）propagation_nested如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按transactiondefinition.propagation_required 属性执行。这是一个嵌套事务,使用jdbc 3.0驱动时,仅仅支持datasourcetransactionmanager作为事务管理器。需要jdbc 驱动的java.sql.savepoint类。有一些jta的事务管理器实现可能也提供了同样的功能。使用propagation_nested，还需要把platformtransactionmanager的nestedtransactionallowed属性设为true;而nestedtransactionallowed属性值默认为false;

<code>//事务属性 propagation_nested</code>

单独调用methodb方法，则按required属性执行。如果调用methoda方法，相当于下面的效果：

<code>savepoint savepoint = </code><code>null</code><code>;</code>

<code>savepoint = con2.setsavepoint();</code>

<code>}</code><code>catch</code><code>(runtimeexception ex){</code>

<code>con.rollback(savepoint);</code>

当methodb方法调用之前，调用setsavepoint方法，保存当前的状态到savepoint。如果methodb方法调用失败，则恢复到之前保存的状态。但是需要注意的是，这时的事务并没有进行提交，如果后续的代码(dosomethingb()方法)调用失败，则回滚包括methodb方法的所有操作。

嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

propagation_nested 与propagation_requires_new的区别:它们非常类似,都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。使用propagation_requires_new时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务不是一个真正的嵌套事务。同时它需要jta事务管理器的支持。

使用propagation_nested时，外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚，它是一个真正的嵌套事务。datasourcetransactionmanager使用savepoint支持propagation_nested时，需要jdbc 3.0以上驱动及1.4以上的jdk版本支持。其它的jta trasactionmanager实现可能有不同的支持方式。

propagation_requires_new 启动一个新的, 不依赖于环境的 "内部" 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行。

另一方面, propagation_nested 开始一个 "嵌套的" 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交。

由此可见, propagation_requires_new 和 propagation_nested 的最大区别在于, propagation_requires_new 完全是一个新的事务, 而 propagation_nested 则是外部事务的子事务, 如果外部事务 commit, 潜套事务也会被 commit, 这个规则同样适用于 roll back.

propagation_required应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。

Spring框架系列相关面试问题

继续阅读

neo4j之cypher使用文档

Dijkstra--简易版（最短路径）

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

NOSQL安全攻击

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

登录plsql 报错 the account is locked --用户被锁

Effective Java 8:通用程序设计

SequoiaDB巨杉数据库C++驱动概述

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method

hdu7108哈希