标签：color 上下文 管理器 静态方法 getname exe single springweb mapped
⑴Spring是为了解决企业应用开发的复杂性而创建的，优秀的轻量级企业应用解决方案，开放源代码，主要特点是采用分层结构，允许单独使用某一模块，也可以将多个模块组合使用。
⑵企业应用：为了满足企业运行需要开发的软件系统，现在的企业应用大多运行在开放性平台（存在信息交互的可能性），不再是孤立的系统，而是在相互联系中构成了一个系统群。
⑶轻量级：轻量级框架如Struts、Spring，侧重于降低开发的复杂度，体积小，消耗小，相应地处理能力有所减弱。
⑷JavaBean：使用java语言编写的可重用组件，主要用作数据的载体。
⑸EJB:EnterpriseJavaBean，服务器端组件模型，定义了一个用于开发基于组件的企业应用的规范，本身复杂而繁琐。
⑴Spring采用分层结构，每一个模块可以单独使用，也可以联合使用。
⑴IoC:Injectionof Control，控制翻转。
⑵AOP:AspectOriented Program，面向切面编程。
⑴Springcore：Spring框架的核心，提供了Spring框架的基础功能，实现了IoC,包含重要的类BeanFactory。BeanFactory是IoC的容器，负责bean的实例化、初始化、使用与销毁。
⑵Springcontext:继承了BeanFactory，添加了许多功能，如国际化、数据校验等。
⑶SpringAOP:继承AOP的所用功能，通过事务可以将Spring管理的任意对象AOP化。
⑷SpringDAO:提供了JDBC的抽象层，简化了数据库厂商的异常错误，大幅度减少了代码，并且支持声明式事务与编程式事务。
⑸SpringORM;兼容所有流行的ORM框架，完美地整合了Hibernate。
⑹SpringWeb:提供了Servlet监听器上下文与Web上下文，集成了现有的Web框架，如JSP、Struts。
⑺SpringMVC:建立在Spring的核心功能之上，具有Spring框架的所有特性。
一个接口，通过读取XML配置文件中javabean的定义，实现对javabean的创建、使用与管理。
BeanFactoy的一个实现类，通过流行的XML文件格式读取配置信息来加载javabean，具体加载过程：
Resource resource=newClassPathResource("xxxxx");
BeanFactory factory=newXmlBeanFactory(resource);
Objectobj=(Object)factory.getBean("xxxx");
⑴其中Resource是一个接口，ClassPathResource是一个实现类，用于将资源封装成对象。
⑵classpath:代表类路径，因为程序执行最终使用是类文件，从类路径中加载，所以凡是程序运行必需的文件都要放在类路径中。Eclipse作为一种java集成开发工具，会将src目录下的文件自动放到类路径下。
一个接口，继承了BeanFactory,添加了许多功能，如国际化、数据验证等，有三个比较重要的实现类：
⑴ClassPathXmlApplicationContext:从类路径下加载配置文件，一般常用此类加载applicationContext.xml文件。
⑵FileSystemXmlApplicationContext:从指定路径加载文件，适用性范围广。
⑶WebApplicationContext:Spring与Web整合后在Web中的容器。
一种思想，依赖注入是该思想的一种事项，将创建实例的任务交给IoC容器，需要实例时向容器发送请求即可，这样降低了引用类A对被引用类B的依赖,即B发生改变，A需要修改很少一部分，甚至不需要修改。
⑴在传统开发中，A类调用B类,就必须在内部创建B类，B b= new B(),当B类被删除，就需要修改A类的代码，这样A类就受到B类变化的拖累。而如果A类调用的是B类的接口，并且实例对象由外部创建，当外部实现类发生改变时，只要提供一个满足要求的实现类，A依然可以正常运行，不需要修改A中的代码，B的变化没有波及A。
⑵IoC降低耦合度是在对象创建过程实现的。
⑴IoC容器将A对象依赖的B对象注入到A中，叫做依赖注入。
⑵依赖注入的几种方式：
①setter注入：底层通过调用A中的setter方法将B注入。
配置文件的编写：
<bean id="引用变量"class="全限定性类名"> <property name="属性名"> <value>属性值</value> </property> </bean>
⑵构造器注入：底层通过调用构造方法将依赖注入。
配置文件的编写：
1 <bean id="引用变量"class="全限定性类名"> 2 <constructor-arg> 3 <value>参数值</value> 4 </constructor-arg> 5 </bean>
①使用构造器注入，配置文件中标签的赋值顺序必须与构造方法形参定义顺序一致，否则抛出出错。为了避免顺序不一致导致的错误，在配置文件中为每一个赋值标签设定一个index值，对应其要赋值的形参在构造器中的顺序：
1 <constructor-arg index="0"> 2 <value>参数值</value> 3 <constructor-arg>
②类中要有对应的构造方法。
⑶当属性为集合时在配置文件中设定初始值的方法为：
①数组与List集合：
1 <list> 2 <value>value01</value> 4 <value>value02</value> 5 </list>
数组还有一种更简单的赋值方式,值写在一块，用逗号隔开：
1 <property name=""value="value01,value02"/>
②Set集合：
1 <set> 2 <value>value01</value> 3 <value>value02</value> 4 </set>
③Map集合：
<map> 2 <entry key=""value=""/> 3 <entry key=""value=""/> 4 </map>
④Properties对象：
1 <props> 3 <prop key="xxx"></prop> 5 <prop key="xxx"></prop> 7 </props>
<property name=""> <ref local="id"/> </property>
⑴将一个bean调用的另一个bean自动转配到该bean中,通过<bean>标签的属性autowire实现。
⑵几种常用的自动装配方式
①byName:通过名称装配，将IoC容器中与属性名同名的bean注入。
配置文件编写：
<beanautowire="byName"id=""class=""/>
按名称装配的不足：如果IoC容器中存在多个同名而类型不同的bean，注入后就会发生错误。
②byType：将与属性相同的bean注入。
配置文件编写：
<beanautowire="byType"id=""class=""/>
按类型转配的不足：如果IoC容器中存在多个类型相同的bean，IoC容器会因为无法识别需要的bean而报错。
如果希望内部bean只能通过外部bean访问，那么将内部bean的定义放在外部bean内部:
<bean id="xxx"class="OuterClass"> <property name="innerClassAttrName"> <bean class="InnerClass">//因为不支持外部对象引用，所以不需要定义id <property name="">xxxxx</property> </bean> </property> </bean>
在配置文件中，如果多个bean拥有共同的属性，分别为每一个bean配置这些共同的属性，数据冗余，为了消除冗余，将这些共同的属性提取出来，定义在一个抽象bean中，其他bean通过引用该抽象bean为属性赋值。抽象bean集中了共同属性，统一赋值。
⑴适用于为同类的bean赋值。
⑵配置文件编写：
<bean id="abstractBean"class="ClassA"abstract="true"> <property name=""value=""/> ........为共同属性赋值.......... </bean> <bean id="xxx"parent="abstractBean"> <property name=""value=""/> ........为特有属性赋值.......... </bean>
abstract="true":将该bean定义为抽象bean，以避免直接使用该bean，即定义为抽象以后，通过getBean无法访问该bean。
⑴适用于为不同类型的bean赋值。、
⑵配置文件编写：
<bean id="abstractBean"abstract="true"> <property name=""value=""/> ........为共同属性赋值.......... </bean> <bean id="xxx"class=""parent="abstractBean"> <property name=""value=""/> ........为特有属性赋值.......... </bean>
1.bean：Spring中的bean就是由Spring创建、装配与管理的对象。
2.作用域的不同，bean的管理者与生命周期不同。
⑴第一种方式：<bean id=""class=""/>：采用默认值singleton。
⑵第二种方式：<bean id=""class=""singleton="true/false"/>。
⑶第三种方式：<bean id=""class=""scope="singleton/prototype"/>。
⑴singleton：bean采用单例模式，对bean的请求返回的是同一bean对象，生命周期与IoC容器相同，由IoC容器管理。
⑵prototype:采用多例模式，每一次请求获取的都是不同的bean对象，IoC容器将对象交给使用者，由使用者管理。
1.Spring Expression Language,用于在配置文件中动态地为属性赋值，只赋值一次，该值可以来源于容器中其他bean的属性，调用bean方法的返回值，也可是调用容器以外其他类静态方法的返回值。
2.SpEL表达式只在初始化阶段为属性赋值，一旦初始化完成，表达式失效，即只是将beanA在配置文件的属性值传递给beanB的属性，并不是动态地保证beanB的属性值始终与beanA的属性值相同。这一点也可以从配置文件的功能来考虑，配置文件就是用来在初始化阶段为属性赋值，一旦初始化完毕，配置文件的任务就完成了，后续不再发挥作用。
3.基本语法格式：#{}。
4.调用容器中其他bean的属性：#{beanName.attrName}。
5.调用容器中bean的方法：#{beanId.method(arg)}。
6.调用容器以外其他类的静态方法：#{T(全限定性类名).method(arg)}。
7.在配置文件中的使用：<property name="xxxx"value="#{xxxx}"/>，或者
<property name="xxxx"> <value>#{xxxx}</value> </property>
⑴singleton:作用域范围singleton的bean生命周期与IoC容器的生命周期相同，容器初始化时创建，容器销毁时销毁。
⑵prototype：作用域范围prototype的bean由容器创建提交给请求方，生命周期由请求方负责。如果请求方不销毁，bean不会一直存在。
2.bean的生命周期可分为11个阶段，即总共有11时机可以用来改变bean。除自定义的BeanPostProcessor适用于所有bean而单独创建外，其他的都通过bean实现相应的接口实现，如BeanNameAware\BeanFactoryAware
\InitializingBean\DisposableBean等。
①定义在setter方法执行完毕后调用的方法，即初始化完毕之后，该方法必须无参，在配置文件中配置：
<bean init-method="方法名">。
②定义在IoC容器关闭以后调用的方法，必须无参，在配置文件中配置<bean destory-method="方法名"/>
①一个接口，其实现类只有在配置文件中配置之后才可以使用，由底层调用，配置时无需设定id。
②容器中所有的bean在初始化阶段都会调用其中的两个方法：
postProcessBeforeInitialization:在bean初始化完毕之前由容器调用；
postProcessAfterInitialization:在bean初始化完毕之后由容器调用。
1.一个项目通常由一个团队的多个成员合作开发，如果在开发阶段共用一个配置文件，不仅降低了效率，而且不同的人共同操作，还容易发生错误，这是就需要允许多个配置文件的存在，而Spring正好提供了对多个配置文件的支持。
⑴两个配置文件各自单独存在，不存在包含关系。
⑵在java代码中读取平等关系的配置文件需要使用指定类的可变参数的形式：
new ClassPathXmlApplicationContext(String...)
⑴一个配置文件在形式上包含另一个配置文件，通过在配置文件中加入如下内容包含其他配置文件，读取该配置文件即可：
<import resources="classpath:xxxxx.xml"/>
①在配置文件路径前一定要加classpath,为底层指定加载方式，因为配置文件的加载方法有多种，以ClassPath开头的类从类路径加载，而以FileSystem开头的类从文件路径加载，在java中加载时使用ClassPath开头的类实际上已经设定了文件的加载方法。因为程序员只负责加载外层文件，内层文件的加载是由底层负责的，如果不指明加载方式，底层无法加载，底层执行过程大致是：提取classpath，然后进行判断，根据判断结果选择加载方式，如果classpath不存在，底层就无法进行判断，无法运行，就会抛出错误。
②classpath是一个单词，path的首字母不能大写。
1.注解是注册的一种，可以取代在配置文件中的配置。
2.注解的优点
在java源文件中直接注册，不需要编写配置文件，比较方便，而且标注在类中，可以清楚地看到注释与类的关系。
3.在配置文件头加入context约束，因为要使用<context>标签，只有该约束中有。
4.注解需要在配置文件中添加<context:component-scanbase-package="xxx"/>,注册扫描器，因为Spring不同于Hibernate与Struts，没有默认的配置文件，被动加载，必须显式指明配置文件，因此当采用注解开始时也必须显式
指明组件位置。
⑴如果包名为xxx,表示扫描该包及其子包；
⑵如果包名为xxx.*,表示只扫描子包。
⑴@Component(value="相当于配置文件中的id")：表明该类是一个组件，扫描时容器会创建该类的实例，这是bean注解的第一步，先让容器把该类当做需要创建bean的类。
⑵@Scope(value="singleton/prototype"):设置作用域。
⑶@Value(value="")：为一般属性赋值。
⑷@Resource(name=""):为域属性赋值。域属性就是自定义类的对象。@Autowired:Spring提供的域属性注入注解。
⑸@PostConstruct:在bean内部设定在初始化完成之后调用的方法。初始化完成的标识是InitializingBean实现类的方法afterPropertiesSet调用完毕。
⑹@PreDestroy：在bean内部设定bean销毁前调用的方法。
1.SpringJUnit4提供了对bean的简化测试方案，进行简单设置之后，测试bean时就不需要在创建容器，可以直接使用bean。
⑴在类上加@RunWith(SpringJUnit4ClassRunner.class):表示采用SpringJUnit4进行测试。
⑵在类上加@ContextConfiguration(locations="classpath:xxxx.xml"):指明配置文件。
⑶在域属性加@Autowired:按照类型注入，也可以采用其他方式注入。因为并不是所有的域属性都是bean，有的可能是测试类新建的。
⑷然后在测试类方法中就可以直接使用bean了。
十二只有在对象由Spring容器创建时，属性与引用的其他的bean才会被注入对象中。在程序手动创建时，容器不会对对象施加任何作用。
1.Aspect Oriented Program,面向切面编程，一种编程思想，建立在动态代理机制之上。
⑴在AOP产生以前，OOP是编程的基本原则，所有对象执行需要的代码都必须写在类中。如果多个类拥有一部分相同的代码，那么这些代码就必须在每个类中都编写，不仅代码大量重复，而且不便于维护，这时就产生了将那些重复出现、与业务无关的代码从业务中分离出来的思想，就是AOP。AOP将重复的、与业务无关的代码从业务中分离处理，业务执行时切入业务中，形式上与业务分离，执行时与业务结合，不仅便于维护，而且降低了业务逻辑部分与非业务逻辑部分的耦合度。
3.简单讲，AOP就是将无关且重复的部分从代码中分离处理，执行时再切入代码中。
⑴切面：对象执行过程中切入流程的、与业务逻辑无关的代码。与业务无关、重用度高的代码适合用作切面。在程序中，切面是一个集中了通知的类。
⑵切入点：切面切入流程的点，也是切面注入流程的点，Spring只支持方法类型的切入点，即切面只能在对象方法执行前后切入，不能切入方法内部。
⑶通知：切入点被横切时，所采取的业务逻辑，由通知确定执行那个切面。通知是切面中的方法。
⑷目标对象：切面切入的对象。
⑸织入：将切面功能应用于目标对象的过程。
⑹引用：动态地向目标对象添加属性与方法的过程。
1.Spring自身提供了对AOP思想的实现，主要借助内置接口的实现类与配置文件完成。
⑴Advice:通知，切入点被横切时采取的处理逻辑，即在切入点前后执行的方法。在Spring中，Advice是一个层级比较高的接口，具体使用的通知都间接实现了该接口。缺点是，一旦定义就对所有方法都起作用。
⑵Advisor:顾问，Advice的装饰者，可以对方法进行筛选，使通知只对选定的方法起作用。常用到的两个实现类：
①NameMatchMethodPointcutAdvisor:列举选定的方法，使通知只对选定的方法有效。
②RegexMethodPointccutAdvisor:通过正则表达式匹配方法。
⑴前置通知：在切点执行前执行，实现MethodBeforeAdvice实现。
⑵后置通知：在切点成功执行后执行，排在环绕通知之后，方法无返回值不可以修改返回值，实现AfterReturningAdvice。
⑶环绕通知：在切点执行前与执行成功后执行，可以修改返回值，实现MethodInterceptor。
⑷异常通知：在切点抛出异常时，执行，实现ThrowsAdvice.
⑴Advisor是Advice的装饰者，可以为Advice指定方法，因此需要传入Advice与方法，将切点与目标方法绑定。
⑵采用NameMatchMethodPointcutAdvisor:
<bean id=""class="Advisor的两个实现类其中一个"> <property name="advice"ref="通知名"/>//装饰的通知 <property name="mappedNames"value="方法名"/>//即切点 </bean>
⑶采用RegexMethodPointcutAdvisor:
<property name="advice"ref="通知名" /> <property name="pattern" value="正则表达式，匹配对象时接口的方法" />
⑴代理通过ProxyFactoryBean类创建，底层执行Proxy.newProxyInstance(),对比底层实现，为该类属性赋值，动态地执行：
<bean id=""class="xxxxxx.ProxyFactoryBean"> <property name="targetName"name=""/> <property name="interceptorNames"value="通知名或顾问名"/> </bean>
⑴当有多个目标对象时，使用ProxyFactoryBean创建代理对象时，需要为每一个代理对象编写代理创建过程，而使用DefaultAdvisorProxyCreator,可以自动为目标对象创建代理。因为DefaultAutoProxyCreator底层实现了BeanPostProcessor,由底层自动调用。
⑵配置文件的编写：
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
⑶自动代理生成器只对Advisor有效，Advisor封装了方法，任何一个bean调用了该方法都会被增强。切面类型狭窄，目标对象广泛。
⑴该代理生成器弥补类基于顾问的代理生成器无法选择通知、无法选择目标对象的不足。
⑵配置文件的编写：
<bean id="proxy"class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames" value="target" />//选择要代理的对象 <property name="interceptorNames" value="methodInterceptor" />//选择切面 </bean>
8.无论是基于顾问的，还是基于beanName的自动代理生成器，都可以同时代理多个目标对象，为了区分被代理的目标对象只能通过目标对象来获取代理对象，这样才能保证一个代理对象指向一个目标对象。
1.AspectJ是一种独立于Spring框架的AOP思想实现，被Spring框架兼容，切面不需要实现特定的接口，就是普通的POJO类，比Spring提供的AOP更强大、灵活、边界，在实际开发中使用较普遍。
2.在AspectJ代理中，Spring容器充当代理工厂。
<aop:configproxy-target-class="true/false"> <aop:aspect ref="切面所在类的id"> ---将切点定义在切面内，对其他切面不可见。也可以将切点定义在切面外，对所有切面可见--- <aop:pointcut ref="切点所在类的id" expression="execution(切入点表达式)"/> <aop:before method="方法名"pointcut-ref="切点id"/> <aop:after method="方法名"pointcut-ref="切点id"/> </aop:aspect> </aop:config>
①什么是切入点表达式？
用于限制切入点的表达式，与表达式匹配的方法都可以用作切入点
②基本结构：[访问权限] 返回值类型 [全限定性类名] 方法名(..).
():匹配不带参数的方法。
(*):匹配带一个参数的方法。
(..):匹配带任意形式参数或则不带参数的方法。
③切入表达式的构成：
*:代表若干字符；
..:代表多级目录；
+：代表该类及其子类。
⑵<aop:config>:配置AOP的全部信息，包括切面、切点。proxy-target-class指明所用的代理机制，CGLIB,还是基于接口的代理JDK，默认为false，使用基于接口的代理。
⑶<aop:aspect>:配置切面，包含切点前执行的方法、切点后执行的方法、适用的切点等。
⑷<aop:pointcut>:定义切点，Spring只支持方法类型的切点，id属性为该切点指定一个id值，供他处引用，expression="execution(* 方法)"指明用作切点的方法，*必须有，之后跟一个空格。
⑸<aop:before>:指明在切点前执行的方法，pointcut-ref属性指明适用的切点。
⑹<aop:after>:指明在切点后执行的方法，无论切点是否成功执行都会执行，pointcut-ref属性指明适用的切点。
⑺<aop:after-throwing>:在抛出异常后执行。
⑻<aop:after-returningreturning="返回值result">:在返回值之后执行,返回值名必须与方法形参名相同。
⑼<aop:around>:紧贴代理对象方法前后执行，方法必须有返回值，可以修改目标方法的返回值。
①当使用环绕通知时，目标对象的方法只在环绕方法内部被调用后才可以执行，因为环绕通知底层采用MethodInterceptor,而拦截器内部必须显式地调用后面的方法，进程才能推进。
②目标对象的方法可能有返回值，因此环绕通知必须有返回值。
Data Access Object,数据访问对象，封装了一些对数据库进行持久化操作的方法，将持久化操作与一般的业务逻辑分开，便于维护与测试。封装了JDBC、简化了对数据库操作的接口。在实际开发DAO层由两部分构成，一部分是抽象DAO,一部分是其实现，DAO层提供了业务逻辑中可能用到的针对数据库的元操作，业务逻辑通过对DAO实现层方法的组合来操作数据库。
数据的来源，一般指数据库，又称数据连接池，一个数据源之所以成为数据的来源，最基本的是与数据库建立连接，数据库连接四要素。数据源是多用户访问情况下必须配置的，为了提交访问效率与速度。
①Spring提供的数据源DriverManagerDataSource,在实际开发中很少用到，常用到第三方数据源C3P0、DBCP。
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName"> <value>com.mysql.jdbc.Driver</value> </property> <property name="url"> <value>jdbc:mysql://localhost:3366/db_spring</value> </property> <property name="username"> <value>root</value> </property> <property name="password"> <value>123</value> </property> </bean>
②C3P0数据源：
<bean id="c3p0"class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver" /> <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3366/db_spring"/> <property name="user" value="root" /> <property name="password" value="123" /> </bean>
③DPCP数据源：
<bean id="dbcp"class="org.apache.commons.dbcp2.BasicDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://127.0.0.1:3366/db_spring"/> <property name="username" value="root" /> <property name="password" value="123" /> </bean>
⑴JdbcDaoSupport:支持以基础的JDBC技术操作数据库的抽象类，开发者需要设置数据源，通过子类获得JdbcTemplate来访问数据库。
①基本原理：利用框架提供的类DriverManagerDataSource创建与数据的连接，然后通过该类的实例获得Connection对象，后续操作同JDBC相同。Dao层实现继承JdbcDaoSupport,内部获取getJdbcTemplate进行底层数据库操作。
②利用JdbcDaoSupport访问数据库的实现：
Dao的实现层继承JdbcDaoSupport,getJdbcTemplate获取模板对象，通过模板对象封装的方法操作数据库：
update:在模板中增删改统一用updae方法，几种重载形式：
update(sql,arg):其中arg是可变长度参数，用来为sql语句中占位符赋值。为了安全与复用，sql与hql均采用参数绑定机制。
queryForObject(slq,requiredClass,arg):用于查询一个字段，并且查询结果唯一。requeredClass表示查询字段的类型，以便对查询结果转型。
queryForList(slq,requiredClass,arg):用于查询一个字段，结果可能有多个。
queryForObject(sql,rowMapper,arg):查询结果是一个对象，其中rowMapper用于将查询字段封装成一个对象，查询结果必须包含对象的全部属性。
query(sql,rowMapper,arg):返回对个对象。
③数据源注入时自动创建模板，所以不需要在Dao的实现层显式注入JdbcTemplate的，即注入数据源时自动创建模板。
④系统自动在方法结束时销毁JdbcTemplate对象，因此每次在方法中使用时都需要重新创建。
⑤HibernateDaoSupport:支持在Hibernate中操作数据库的抽象类，开发者需要设置SessionFactory，然后获得Hibernate的实现,HibernatDaoSupport底层实现复杂，效率低，不建议使用。
4.JdbcDaoSupport/HibernateDaoSupport层级都高于对应的模板类，内部都提供了获取相应模板类的方法，与数库的交互通过模板类来完成。应用Spring提供的DAO模块时，自定义类通常继承XXXDaoSupport类，在自定义方法内部
获得响应模板类来具体操作数据库。
5.在实际开发中，先定义一个抽象DAO层，再创建一个实现层，抽象DAO层增删改查方法的名称与JDBC底层操作名称一致，服务层即具体利用DAO实现层进行数据库操作的层中，增删改查方法的名称与DAO层对应名称区分开。
1.Spring事务管理是基于AOP实现的，而Spring的AOP是以方法为单位的，所以Spring的事务属性就是对事务应用到方法上的策略。Spring的事务管理是利用AOP技术在DAO核心代码前后切入事务管理代码实现的。
2.Spring提供了PlatformTransactionManager接口来管理事务，该类提供了用于事务管理的通知，可以将该类视作切面，两个重要的实现类，不同的访问数据库的方式采用的实现类不同：
⑴DataSourceTransactionManager:适用于JDBC、Mybatis。
②HibernateTransactionManager:适用于Hibernate。
⑶事务管理器的核心操作是对事务的回滚与提交，而进行回滚或者提交时都需要建立与数据库的连接，因此需要把数据源传入事务管理器中。
3.Spring在默认情况下，发生运行时异常回滚，编译时异常提交。程序员可以改变回滚方式。
4.事务的四大属性分为传播行为、隔离级别、只读和超时。
⑴事务的传播行为用于确定是否将事务应用在方法上以及应用的策略，比如应用当前事务，新建事务。
5.Spring框架提供了两种对AOP思想的实现：一种是Spring自身的实现，另一种是兼容的AspectJ的实现，由于Spring的事务管理是基于AOP的，所以与AOP实现相对应，事务管理也有两种类型。
6.Spring事务管理的基本构成：代理工厂、目标对象、切点、切面、事务属性。
1.在Spring AOP构成的四个要素：代理工厂、目标对象、切点、切面。
⑴代理工厂：在SpringAOP事务管理中采用TransactionProxyFactoryBean充当代理工厂。
⑵切面：在Spring事务管理中PlatformTransactionManager充当切面。
<bean id=""class="xxxTransactionProxyFactoryBean">//代理工厂 <property name="target" ref=""/>//目标对象 <property name="transactionManager"ref=""/>//切面 //事务属性，就是事务应用到目标对象方法上的策略 <property name="transactionAttributes> <props> <prop key="目标对象方法">事务四大属性</prop> </props> </property> </bean>
因为目标对象中有多个方法，并不是所有方法都需要被事务管理，被事务管理的方法所需要的管理方式也不同，因此需要通过事务属性进行个性化定制，如ISOLATION_DEFAULT,PROPAGATION_REQUIRED,-Exception。
4.Spring事务管理默认在发生编译时异常时提交，也可以设置成发生编译时异常回滚，在事务属性中设置："-Excpetion"，以负号开头，加异常，标识当发生该异常时事务回滚。
<tx:advice id="advice"tansaction-manager="transactionManger"> <tx:attributes> <tx:method name="buyStock" isolation="DEFAULT"propagation="REQUIRED"rollback-for="StockProcessException" /> </tx:attributes> </tx:advice> <aop:config> <aop:pointcut id="p01"expression="execution(xxxx)"/> <aop:advisoradvice-ref="advice"pointcut-ref="p01"/> </aop:config>
1.以上两种事务管理是基于配置文件实现的，缺点是需要为每一个代理对象创建代理工厂，因此提供了基于注解的实现,可以方便地为多个对象创建代理：
⑴在配置文件中添加：<tx:annotation-driventransaction-manager="transactionManager"/>,指明事务管理器。
⑵在目标对象方法上添加以下注解，设定事务的属性:
@Transactional(isolation =Isolation.DEFAULT, propagation = Propagation.REQUIRED, rollbackFor=StockProcessException.class)
标签：color 上下文 管理器 静态方法 getname exe single springweb mapped
原文地址：http://www.cnblogs.com/tonghun/p/6914594.html
