Spring
/ i) i- N$ O' Y4 w8 `6 t0 b/ ^- 是什么?
# h3 c7 Z3 ^9 B9 S! ~. a/ O1 x; l: G2 e3 e( \
Spring是基于JEE的轻量级的应用框架
7 T# }" s8 O! ^- 有什么?0 [# G7 d2 K! v8 _- k
8 H: v P1 j: Z; M9 P6 t6 M2 R+ m' v
& z6 \6 h8 A- X4 Y2 t/ j$ H
每个包的功能: Spring MVC:spring 本身提供的web 框架 WEB:集成其他的web 应用的框架,或者说是对其他web应用框架的支持。如struts,webwork JEE :集成一系列的jee的技术(对JEE技术的支持) DAO:封装了JDBC;(对JDBC的支持) ORM:提供了对ORM工具的集成(支持) AOP :面向切面编成 CORE:spring的核心包,提供bean的工厂和IOC容器 4 K9 V2 G) k6 A8 |/ x% I
- 能干什么?
7 x1 a& i8 i) k( I6 W; j( ^6 `8 S* ]0 V1 V* I u
把一系列的jee的技术有效的组合在一起形成以良好的系统
2 V: ^$ [" X% w7 ?: q- 怎么用?8 U1 e2 n: k0 c0 l/ m0 C- w
% y# ~) @2 T% V0 @! t$ y- 搭建web工程,引入spring的jar包2 j5 T) k4 N) j( B
- 在web.xml中添加如下配置+ C+ _ q- l* H$ y- M3 |
" w( i" u& t" d% ]% B
: @: ]7 N2 C0 ]7 i
- Y: z5 c6 P: i" n: w8 @
contextConfigLocation" S0 j9 o1 V: m; `; X6 d$ \. ?
classpath*:applicationContext*.xml U6 }1 o9 J" G4 E8 F( F, w
" \3 u- e- H- G* B q& Q7 D9 L / h1 }+ [- c8 N# H+ L1 z ]
struts2( u: \1 v/ W9 Z$ c5 P% D! w K" u
4 n4 S7 b! l. ~+ J3 y# J: p$ s org.apache.struts2.dispatcher.FilterDispatcher4 F3 L) j/ G7 r/ x$ V1 {( o A* E
5 g- u3 {: t1 s
/ w1 o( R) [ B7 V8 F" b/ l
/ o8 ?# @% B/ L- M0 @: @5 s struts2
1 k* N8 Y/ m* }& M /*+ Y* ~( ?6 {! ~ I
9 c) L4 K' j( D( V. y( p% Z ^) }
( E5 F& ]. R0 J5 ]' \. W; B/ z
# F$ U& a4 a* m! V+ v+ `% x, K
org.springframework.web.context.ContextLoaderListener, \: v& I& ? S, E7 [; f5 p: B
5 K) |# b0 g) _( ]! W" g% u M3 z - 部署
8 C. m5 F2 Y+ v3 a5 l3 Z6 W0 g
# S% E, {- a1 C+ x, X- G2 h( T
( m, O6 N! [* k( V; [
1 i! f2 K3 L# R% |, n* F
+ E# l" ^& n0 s6 x$ F6 z- 容器和bean& q2 o4 H, V1 Y# |( d0 S: W
Bean :是指受spring的ioc管理的对象称为bean 容器 :(与jee的容器类比) Jee :提供组件的运行环境和管理组件的生命周期(不能单独存在) Spring :提供bean的运行环境和管理bean的生命周期(可以单独存在)
8 M, T3 Z% k8 F4 i- U6 k
# E6 n& |* Z5 S- DI依赖注入
9 |* M" b1 J8 V, { \) W! o* {; q
1. 应用程序依赖spring注入所需要的对象 IOC和DI是对同一种事情的不同描述 2.setter注入: 在配置文件中将接口的实现配置为bean在应用程序中注入bean 例如: 在配置文件中
& [; C+ U6 ~, r1 [, M' \
9 V$ N' @& W9 P0 J; a- b5 h4 Y- b
5 m7 f$ ?8 q3 v! h" l在应用程序中 Public DBDAO dao ; Public void setDao(DBDAO dao){ This.dao = dao; } 3.构造器注入 : ]" f9 r! K$ J$ ~- V; P
4.ref 表示参照其它的bean 在参照的过程中一定要注意死循环 5.自动装配———–〉no 自动装配根据名字来匹配相应的bean 尽量不要去自动装配 6.lookup注入 7.singleton 1.单例模式是整个的jvm中只有一个实例 2.spring的singleton是指在spring的容器中只有一个实例 一个生命周期中只有一个实例 8.DI的优点: 1.程序被动等待,强化面向接口编成 2.切断了对象或组件之间的联系,使程序的结构更加松散,运行和维护更加简单 " w! D' X+ P: ^ E" _' F* P' T, B) w
- Aop面向切面编程1 ]$ i$ m: r) C Y! M5 ]
7 }: _ i' `0 [" x
1.AOP面向切面编程 一些较好的模式或者是示例—-范式$ c; f+ w3 Q; p' W$ m! G7 d; o7 B
切面:一个切面代表我们所关注的一系列的共同的功能点(模块之间的共同的功能点) 2.AOP的思想: 主动—->被动(追加功能)
3 S! t% m$ y0 @' m/ e: Y 3.AOP 的概念6 g( S/ c- J+ t/ H% ~
1.切面 :我们所关注的功能点 2.连接点 :事件的触发点(方法的执行) 3.通知 :连接点触发时执行的动作(方法) 4.切入点 :一系列的连接点的集合 (连接点的模块化) 5.引入 :扩展的功能 6.目标对象 :包含连接点的对象 7.aop代理 :实现机制 8.织入 :把advice和目标对象连接起来 4.AOP的事件机制4 m: D+ ~' |" K( Z; _/ l8 L; {
1.通过切面找出一系列共同的功能点 2.找到目标对象(在标准的spring 中 接口的实现类为target) 3.找到切入点 4.确定连接点 5.通知spring AOP,查询xml文件,通过代理找到advice。 6.由aop代理来实现动态织入 H& t. u; `/ |; f
9 x6 o* ]9 n7 B) C8 K1 m! g1 t6 F; ~$ |, P: m: s' R
" [ {2 O% I* J& b8 d3 T% }3 f- G
8 v" `" @+ _6 |/ M& s$ I# {5 H
8 {9 s8 z! ~: H+ T. A/ g* k8 W( A4 |; C- m, W, `7 B7 E* n1 a
5. AspectJ
% p" g1 ?( g! G: Q2 n+ c* I, ~( \ 5.1.在xml中配置比较烦琐 ]- W3 G8 D+ Z7 x! {* T y
所有的入口必须从一个代理(ProxyFactoryBean)开始
# Q3 a6 B! L) F; n4 k/ @+ e 5 y$ f7 ^3 X4 |% H% W0 z4 e! y- F
/ m% T p5 f* V4 I$ U5 i' S2 G4 ? v 4 A1 a p; @; o4 Y+ R
6 a# W0 A5 d0 e v2 X; w
5 S5 U1 }& F: `& S% S5 |0 P! E' p6 R
3 G( U) @! ^4 m! n
5 {5 p. Q8 a+ B; O5 N/ A( e
. `# t w$ D- ^3 a7 g* {expression=“execution(* com.javakc.aop.MyTarget.t*())”/>, a. ~9 ?3 f; s6 ~& d' C. X+ {& Z
* ~$ n! P4 T+ w3 y8 o; \" B% W # o! |$ M/ n5 G% D! x# }( J
' c+ Y& X, t; s6 k! T 5 ^7 @/ P) x' B" q' J% ^0 M
8 A& a( ?( x& ] U: k& M5.3.使用注解的方法相对简单: T6 x p8 p. }0 I, C" n* y
@AspectJ的基本语法, p+ I+ v5 F! |! A: F
1.@Aspect声明一个切面,将一系列的共同的功能定义成一个切面
- J7 G/ E! k4 x4 v. c 直接在类上定义@Aspect2 k8 s$ }2 A/ a- c& |5 s$ u
2.@Pointcut声明切入点& x+ z7 g2 m8 F
2.1、用一个专门的类来定义pointcut,类中的方法名就是该pointcut的名字% `% @3 k$ W" G" B
2.2、可以使用匿名的pointcut7 g" Z( r, e, r+ f" Z! Z
2.3、执行切点的几种方法
& k! s. N9 p) [9 R) i. X0 T 2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法
, N# N0 `, B9 P1 t& m( l 2.3.2 within 指定到包,不能指定到类
8 q- e9 p# Q. f5 ~3 W+ @ within(”com.javakc.spring..*”)
+ ^2 R; E$ v3 l* T t9 @% m: ] 2.3.3 this 指定到实现接口的所有的实现类
5 A" z/ a9 f2 v0 d 2.3.4 target 指定具体的实现类
: L3 b) G1 ?: z4 V% l, ?! @ 5.4.advice的五种类型的示例0 U3 W; T2 I3 \# y$ q! t
客户端必须从接口走才能得到监控,实现想要追加的功能
]) \1 X4 H# ]" n1 H7 d 5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)* w1 y/ b% r) Y; R% o
追加的方法的参数名字一定要与retrning的名字相同
H; C8 e& {4 N M7 j6 B 在注解@AfterReturning中必须加上pointcut和returning两个参数
4 \" S' u$ }/ w pointcut指所要监控的目标对象的方法! D- n/ X$ H: U A/ E* {
得到目标对象的方法的返回值,来作为参数,进行下一步的处理,参数没有顺序,按参数的名字进行匹配
) @/ a1 a5 }: f1 g2 U/ p( x 完成追加的功能
8 b* [5 i6 ~; N2 t5 y 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
4 l) c( R. c, E: s7 _1 s (1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
4 }: T: Q) E9 Y (2).$ v. B- X' F5 m: }4 ?
2.直接引用匿名的pointcut
1 Y: e; u7 D+ b0 T7 L% A (1).@AfterReturning(“execution(
9 X" b8 B+ @; l4 m7 G+ m# x" |* ^ * com.javakc.spring.schemaaop.Api.test4())”)
+ ~& l+ b% D% P$ }1 | (2).@AfterReturning(pointcut=1 X% V3 E1 P6 q* `# g _* A% t( Y
“com.javakc.spring.schemaaop.TestPointcut.t4() &&
& W3 t7 ~! D8 { args(str)”, returning=”retVal”)
. A7 g& @, ~; w' W( ^: Z$ i# A- X0 C4 O: L @AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)- J% {* _" A5 ~* B6 B: _! d& N8 k# W
public void testAfterReturning(String str,Object retVal){ T, B) U/ {' U/ ?
System.out.println(“afterReturning1=>”+retVal+”=>”+str);
: ?# F5 g3 |& H! X" z- {8 {6 \ }
+ c7 {+ m- W& M$ Y; v- T. A: d 5.4.2.@Aronud1 O. d: o, q$ B4 K1 I; q$ K# F) T
注解@Around环绕追加功能;" P; }5 X. m4 @5 k+ `
在执行目标对象的方法的前、后追加功能;7 t: q* W' i. X5 E _" f
必须有参数;第一个参数的类型必须为ProceedingJoinPoint;0 R& }9 s7 r+ R1 _* U
通过ProceedingJoinPoint的实例的proceed来调用所监控的( N @1 A% q2 @8 H
目标对象的方法8 c& e7 R& [# k6 J& l: d1 c
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
" ^6 H$ n) }9 D; Q (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”) r+ j8 N6 p+ M! o
(2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()0 Q2 n; e3 m, w$ c' @& B- ?- H
&& args(str)”)
y" W; o. c" Y1 j& \9 Y8 Q 2.直接引用匿名的pointcut
- ^# O" L! V# ~ (1).@Around(“execution(' G& Z& ?9 ~5 \
* com.javakc.spring.schemaaop.Api.test1())”)) V; B/ l {% X5 o3 q+ H& ^
(2).@Around(“execution(" H5 E* u) u9 C' m
* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)! ]: U, y4 r3 r2 ^7 f8 }
// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”): m D; w9 ^: U2 U! C+ `" k
@Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)4 W) n ^' p, l& L9 [1 O/ |8 x
public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
$ z# ]6 }% E( H, t System.out.println(“around1==========before1pointcut==>”+str)" K* V- b, @' o% {
Object obj = prj.proceed();/ I2 m/ A# \& | p% A3 T: U* o
System.out.println(“around1==========after1pointcut==>”+str);
! l- y# a; R( `) F$ o- @ }1 I1 w9 a8 V& y* J, d0 D" f
5.4.3.@Before
% y3 ^8 x: ?. Q. Y9 R3 j9 U 注解@Before在执行目标对象的方法前追加相应的功能+ t" Z+ `, [9 ~* A- n1 ^
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用6 F( E! p, E- _. l$ z
(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)/ @5 @. b* c8 M; |: y5 p
(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
9 X# @8 \, ?7 k2 d$ W! u; j. P, f$ b 注意args后的名称与参数名相同! q$ |2 J+ x9 D- p
2.直接引用匿名的pointcut5 M: I: f# a- u& k6 O! E
(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)4 @, ^& h8 Y- v
(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)* u! x2 K8 w( L" ?6 K
注意args后的名称与参数名相同; P" c! R" Z s* H' A
// @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)% P5 s3 Y* b3 g8 {6 I ~
@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)6 ?1 g; G+ T# ?1 e9 K& `+ A
public void testBeforeParam(String str){
* D! K6 w3 e8 `" `3 }/ j System.out.println(“before1=param=>”+str);5 p! Y$ M9 q) A$ A# L! B; L
}$ b* Y% K5 G5 v1 I7 M
- L5 L7 p: o2 q0 i3 R' f5.4.4.@After
% @% f" C# Z* @1 v 注解@After在执行目标对象的方法后追加相应的功能
$ Z6 |9 J% T! M; b/ | 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
* k0 @1 c. U u* F% a; I (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)" c) ` @8 x) D# d( T' V2 d) B6 _
2.直接引用匿名的pointcut0 H8 C' d: g2 g7 t) }5 @
(1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
' o3 J3 {# f$ ?( G @After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
7 G/ `* Q; R+ n) k& p' x/ U- L# C public void testAfter(){1 s* o" U) z. K( m7 `
System.out.println(“after1== >pointcut”);3 I/ q @$ K7 U/ o' P t: V2 ~. \7 T
} s$ f* i% t& ^+ B8 M
5.4.5.@AfterThorwing
" ^: [; O! P) p) `+ H
( s) X3 m+ \2 ?% u5 Q& t! J B \! q
+ U7 L( b q" w: D- 描述一下spring中BeanFactory和ApplicationContext的差别, R2 L: [9 l, g
* Z9 m, |: t5 `$ V$ |
BeanFactory是一个Interface,这是Spring的核心。它仅仅只是提供的一些基本功能。ApplicaionContext 也是一个interface,这是从BeanFactory继承过来的所以它具备了BeanFactory的所有功能。但它也从其它的类或interface得到了一些特性。比如提供国际化的消息访问,资源访问,事件传播。 但其主要区别在于BeanFactory是延迟加载,如果Bean的某一个属性没有注入,BeanFactory加载后,直至第一次使用getBean方法调用此Bean时才会抛出异常;而ApplicationContext则在初始化自身时检验,这样有利于检查所依赖属性是否注入;所以通常情况下我们选择使用ApplicationContext. 代码示例: BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(“beans.xml”)); ApplicationContext cxt = new ClassPathXmlApplicationContext(“beans.xml”); " \/ v, Y/ P" E# g& |+ F K; L
- 谈谈spring对DAO的支持
# s5 Y" _' W4 V B4 ]" M0 ?; q1 h
Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
$ G2 R9 x4 K1 M/ \5 n# @! c: h% g0 S" v 简化 DAO 组件的开发。
/ M) t' @$ S3 DSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法,用来简化代码开发。# p# ?- r) N7 O$ o
IoC 容器的使用,提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件,都由容器负责注入到业务逻辑组件中,其业务组件无须关心 DAO 组件的实现。; @1 \+ t$ _2 E! A1 b4 }5 R. `
面向接口编程及 DAO 模式的使用,提高了系统组件之间的解耦,降低了系统重构的成本。
+ P2 i* O. g s$ m 方便的事务管理: Spring的声明式事务管理力度是方法级。+ \+ t* u7 S6 k5 ^. y, k- k0 ^
异常包装:Spring能够包装Hibernate异常,把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常,从而避免烦琐的 catch/throw 及异常声明。. p. e) l$ |6 V: h2 A! F
+ Y6 G2 g$ A3 E" `, S! \. l/ n, S) l: x- G
- 谈谈spring对hibernate的支持6 V0 B0 K+ n. Z8 i" T" P @
( }+ Y- H- `* u6 x9 t+ [
在所有的 ORM 框架中, Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外, Spring 还提供了统一的异常体系及声明式事务管理等。' j$ _5 l) _5 ^( _1 t
一旦 Hibernate 处于 Spring 的管理下, Hibernate 所需要的基础资源,都由 Spring 提供注入。Hibernate 创建 SessionFactory 必需的 DataSource ,执行持久化必需的 Session 及持久层访问必需的事务控制等,这些原本必须通过代码控制的逻辑,都将由Spring 接管 ataSource, SessionFactory, TransactionManager等,都将作为 Spring 容器中的 bean。将这些bean 放在配置文件中管理。# B/ c3 W% m' J9 C! E
1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory,使得配置值很容易被管理和修改,无须使用Hibernate 的配置文件。详细配置如下:
+ v* t& e! r: Z1 J( P5 o . p3 c1 Z2 Q3 a& t9 A9 t8 ~
class=“org.apache.commons.dbcp.BasicDataSource”>
8 S! A( o* L( u, E5 d4 b6 g
( T, N7 ?1 {) [8 z oracle.jdbc.driver.OracleDriver, Y0 {3 T$ N/ U$ U2 h' H+ I
" g9 m4 C% `% B) H2 c; f/ J 2 r: Z( k$ _; \: K* \; ^
jdbc racle:thin localhost:1521 rcl
) n ]* u! L2 g5 u
7 l8 G+ t9 g( t& ?
, b; R) F; r$ _- o/ m- Y; G( n javakc2+ f7 A9 P0 t& W1 {9 ^; R
; c3 N# O9 U$ ^! Q. k; [
2 L0 F6 x+ s' K- a6 D- b; H javakc2
4 W- o4 g3 q9 R7 V$ ` ) @7 W7 l- V+ F5 U+ i
) w# n$ C" e3 J& P: B9 Z# Y
0 B4 X( W4 B' V0 G class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
& H7 _& D) C" i/ D
4 L. b2 X1 D1 ^" K3 B( V' s t4 ~7 S. e! j' X$ Y4 k: ^
$ I) h- K$ e9 \
com/javakc/spring/h3/UserModel.hbm.xml
" Z% t/ z3 F4 S- v
3 x$ |4 S. b/ v7 v' v ; d. H4 f P) D- n$ k9 c
. g' S! d2 R* x1 Z) S
5 u5 R5 p4 x) j/ ~ G0 q! H
hibernate.dialect=org.hibernate.dialect.OracleDialect6 H6 _. }, j( @9 Q1 T8 r
) }8 d* x, W1 m2 L8 A; Z/ V6 P
l# ~9 A' l4 V; v. |* W7 o
# f | y" m( l$ l
, r0 b) W. N$ j1 g' @; U
/ [; e" P. Q& t' P" T. |( o% J4 ]
0 z" i/ |4 L+ u `9 X( o0 \ 如果需要使用容器管理的数据源,则无须提供数据驱动等信息,只需要提供数据源的JNDI 即可。对上文的SessionFactory只需将dataSource的配置替换成 JNDI 数据源,并将原有的 myDataSource Bean 替换成如下所示: class=“org.springframework.jndi.JndiObjectFactoryBean”>* W( z; g$ D4 m
1 Z g9 V- a$ {" J+ Z1 L) }
java:comp/env/jdbc/myds
# S9 @ A/ x4 g0 J 7 H# n) r; `; @2 Q
2、有效的 Session 管理: Dao类继承HibernateDaoSurport后,Spring 提供了 HibernateTemplate,用于持久层访问,该模板类无须显示打开 Session及关闭 Session。它只要获得 SessionFactory 的引用,将可以智能打开 Session,并在持久化访问结束后关闭 Session ,程序开发只需完成持久层逻辑,通用的操作则由HibernateTemplate 完成。 3、统一的事务管理。无论是编程式事务,还是声明式事务, Spring 都提供一致的编程模型,无须烦琐的开始事务、显式提交及回滚。 建议使用声明式事务管理,Spring 的声明式事务以 Spring 的 AOP 为基础。可将事务管理逻辑与代码分离。代码中无须实现任何事务逻辑,程序开发者可以更专注于业务逻辑的实现。声明式事务不与任何事务策略藕合,采用声明式事务可以方便地在全局事务和局部事务之间切换。 Spring声明性事务有两种配置方法,一种是xml配置: * t c H |2 a* [! x
$ W7 d1 X4 @/ j; R. ^0 T
* e/ X! P! s* n- \6 S# j$ Y
+ q6 S: O( X( A/ G% ] ( C* }3 U4 i$ u9 T6 s( z% s6 V0 I
% V s$ g' p3 Y3 l
0 [+ N3 Y# m, Z& Y9 y {
7 x% }! U6 m7 w' E; Y
/ i( d0 z: W! F. D, [/ x 1 B$ B8 b0 N+ y B- w# _& F" o
) M+ ^6 Y0 a2 \/ t5 U 2 u/ ^, F N. ]5 S: k! `9 _
( E0 g1 ]7 x. {1 n& {7 k# a
% `: _% g/ K$ V 另一种是通过注解,在需要添加事务的类上注明 @Transactional 5 R4 v5 ?! Y+ m0 Q5 I L
Spring2.0之前事务的写法
4 x- C0 C; ]+ I N2 H# [ |" z
# N$ `3 F/ o: \6 Z2 s- q, K8 _8 A$ ?: e4 g6 k7 C
class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”
6 s0 h0 Y( s/ d' B+ N" j+ H8 G4 r: u1 R( {6 E
abstract=”true”>3 I _1 V8 Y. M3 L8 |
" ? U A Q, k+ e- K, h
: f6 @3 r1 `( e4 n) b: G2 X
3 \1 f1 d l0 z% N1 v- p3 ~1 H* Q! ~; `; v2 s/ x
PROPAGATION_REQUIRED,readOnly4 J1 K: M$ t& H* c) _
* y! ^- g- }/ f7 e. w3 V$ }
PROPAGATION_REQUIRED0 F3 N2 k" P2 q; G" O7 D% h! q
* x# v- s j _* h7 F6 n
- p! L: T$ ]7 P6 V' ^, j* j$ `9 P/ `4 M
+ |' s A! h. T I# e! K7 w ~
|
; F7 j" `7 w( d L7 C, M" e* G | n6 _% m
- 谈谈Spring对事务的支持
8 K' T" C/ Q v; _0 G3 f: \0 H
, g# D( E+ f0 z4 U7 }
1 u0 j" n! h8 i1 L( ^) Q* ^1、声明式事务管理:
1.流程:由客户端访问—-aop监控—-调用advice来追加事务 2.做法: 2.1 在配置文件的头中引入xmlns:tx 和schema的文件 2.2 2.3 注入数据源
7 X1 b( T0 t4 x- K* i) v) f. L
N. |& V# O/ |( G: i0 T! b
; j. R6 ^! F! W5 V! ]- h. Z% P) v) J: K1 y/ x, x; ~
4 W0 r3 k$ E( y9 X5 h6 X/ L
1 b2 g% `# k0 S+ ]$ ~2.4 由spring实现的事务管理,但需要注入数据源 & q+ p! k' l# f" ?/ B1 F
4 y; k9 ?" } q0 N$ F* l6 ~
) _4 ^( ~& e0 u4 W* K: Z
2.5 事务监控所有的方法(事务加强)
. g& V* p6 a- G1 O, L4 u+ C1 j
1 q4 o7 i3 }. F! A0 p; A6 S9 e/ ?
7 g# H W, c. j6 Z
- }( E4 z* C. D( I& v; o# c y |8 J
$ k# P! y, ?( P1 W' y6 r* S2.6 定义切入点
0 F8 ?/ N* V; P2 s, C- x) O. F0 Y8 C
& _5 ]# \6 y1 w3 t" f g$ `
3 ^* r+ _6 X7 E& ~
) G. g* L4 H" y0 D% e: d2、使用注解实现事务管理: 1.注解@Transcational (可以在类上,也可以在方法上) 2.在配置文件中同样需要注入dataSource和spring的事务管理 3.使用注解的方法来追加事务 注解驱动
1 x3 u1 Y) g% l, r, S! x8 b$ ]7 V6 p' u; j# E: q
如何在Spring中使用Hibernate的事务:
, C9 o2 o; V4 a* C( m& Y9 r* w
) e, [' K: t5 t* W# L9 i
0 f$ W; d. s' U. V+ e% o
Z$ }. R5 I" L- H; j4 p9 D如何在Spring中使用JTA的事务:+ b! a: p# z. h3 v9 D8 B
% K8 b, n9 u# i. \8 }4 y- t0 e |