Spring D, T H. A; Z" Q5 O, X; X7 ^7 e
- 是什么?0 h$ Y' r1 f4 U2 P5 ]! Z
( z; b7 {4 V4 P d
Spring是基于JEE的轻量级的应用框架 0 m. b5 ]+ O# e$ }8 N
- 有什么?
/ l* _1 ^- U3 k8 H4 Q$ V* G6 h: ], V* v) L' [
Q& V3 I) y& v. X
每个包的功能: Spring MVC:spring 本身提供的web 框架 WEB:集成其他的web 应用的框架,或者说是对其他web应用框架的支持。如struts,webwork JEE :集成一系列的jee的技术(对JEE技术的支持) DAO:封装了JDBC;(对JDBC的支持) ORM:提供了对ORM工具的集成(支持) AOP :面向切面编成 CORE:spring的核心包,提供bean的工厂和IOC容器 2 v; d" }4 p) E0 J" @# T9 K0 _
- 能干什么?
! a2 D; F1 R6 f! {+ C1 d+ d
3 g k. @2 _9 F6 Q& P
把一系列的jee的技术有效的组合在一起形成以良好的系统 3 ?# `) P$ I: A+ F1 P6 w
- 怎么用?/ ]2 r/ V4 J) Y# f5 r% ?
6 t; n& W' q* V% o- ?* s4 T* Z
- 搭建web工程,引入spring的jar包
: S8 N1 S, [& h3 I2 h - 在web.xml中添加如下配置% L& _( \' N9 X2 W0 g
3 |0 ^/ u: h8 }/ V+ `
- m* k A, ^. k/ z7 N0 t! H S
' ^5 B U9 |! T( [7 q" ?* s
contextConfigLocation9 ~* ^4 P$ x" a5 I. J/ e; d$ G
classpath*:applicationContext*.xml
6 b" E5 ~: Q0 |; q$ l
# C0 j! B9 ]$ j) H0 N0 } / b- p# W9 U# x6 ?3 ], C2 `
struts2% U: ~$ d/ X8 i5 u: W
; V+ t, W2 d, ?; T) T9 e org.apache.struts2.dispatcher.FilterDispatcher
% q9 u0 r$ m3 r l5 e- [1 M; _% a L" I
! P4 Q$ R% d7 i# ?2 g: P. ]
$ _' v. u5 c; B: O8 M- l! D struts25 D9 T9 [" T5 d- o" v
/*
# D' h/ [$ D3 Q) K7 l g
) c+ b. B% r+ ^' D. \
: X" @* @8 B9 I3 J; s/ H! J+ J
' V4 }4 c+ a0 i0 W( P% L9 R org.springframework.web.context.ContextLoaderListener' w/ ^# R5 ? X( y
/ x' e% U8 F/ A$ a1 e( P
- 部署
E% {. `/ \2 d& B* ?6 U
( {+ k! I8 R, `6 b3 E4 c0 f 0 R; n# b+ [. m
% K ^. A& T) l* s
' f# x! C: q. S O+ |- 容器和bean5 ~" s# G& |9 K4 S
Bean :是指受spring的ioc管理的对象称为bean 容器 :(与jee的容器类比) Jee :提供组件的运行环境和管理组件的生命周期(不能单独存在) Spring :提供bean的运行环境和管理bean的生命周期(可以单独存在)
. v# r8 u* e! @
' D. I9 s7 |. v( f" b0 i# I {8 X- DI依赖注入* S( V3 `* X& `5 Y# K7 F. t
1. 应用程序依赖spring注入所需要的对象 IOC和DI是对同一种事情的不同描述 2.setter注入: 在配置文件中将接口的实现配置为bean在应用程序中注入bean 例如: 在配置文件中 . \1 P. k7 @" V9 Y
( R8 y; }0 V C6 ]/ q. v
+ C! n, ?5 Z+ J* {; W' q6 t) ^+ T$ _
在应用程序中 Public DBDAO dao ; Public void setDao(DBDAO dao){ This.dao = dao; } 3.构造器注入
. |2 d8 q- K& X+ i0 O# Z& i( H4.ref 表示参照其它的bean 在参照的过程中一定要注意死循环 5.自动装配———–〉no 自动装配根据名字来匹配相应的bean 尽量不要去自动装配 6.lookup注入 7.singleton 1.单例模式是整个的jvm中只有一个实例 2.spring的singleton是指在spring的容器中只有一个实例 一个生命周期中只有一个实例 8.DI的优点: 1.程序被动等待,强化面向接口编成 2.切断了对象或组件之间的联系,使程序的结构更加松散,运行和维护更加简单
) z p: ~3 H3 {: ?& z( |9 s- Aop面向切面编程
* g" R8 r3 c8 s$ A* ]
. C l. ]6 j! L+ z8 v! P; W5 o) _
1.AOP面向切面编程 一些较好的模式或者是示例—-范式
" a7 ~ k9 }! g& B7 W6 K1 x 切面:一个切面代表我们所关注的一系列的共同的功能点(模块之间的共同的功能点) 2.AOP的思想: 主动—->被动(追加功能)+ U- [8 s, @% [; b4 ?1 C
3.AOP 的概念
* y5 [+ o, f0 z) M, B& N 1.切面 :我们所关注的功能点 2.连接点 :事件的触发点(方法的执行) 3.通知 :连接点触发时执行的动作(方法) 4.切入点 :一系列的连接点的集合 (连接点的模块化) 5.引入 :扩展的功能 6.目标对象 :包含连接点的对象 7.aop代理 :实现机制 8.织入 :把advice和目标对象连接起来 4.AOP的事件机制
" S! M$ r7 P& Q7 E 1.通过切面找出一系列共同的功能点 2.找到目标对象(在标准的spring 中 接口的实现类为target) 3.找到切入点 4.确定连接点 5.通知spring AOP,查询xml文件,通过代理找到advice。 6.由aop代理来实现动态织入
7 h" E$ B+ s$ _- a+ c& q
/ P6 ?0 K4 y# A& `/ E5 I) l+ O, O9 \ s2 n ~6 Y4 H0 R
8 Z( W3 _3 N9 K7 [3 w: G; t( ]1 Q) o0 L3 t$ u [0 H+ P
4 k4 h; A8 C/ s+ Z3 u
, ~) d: B* n4 d- U5 z0 ^3 w. o* }5. AspectJ& ~) d |0 h+ l( e2 f
5.1.在xml中配置比较烦琐
4 Q& g7 G' Q W/ X: n- _6 ^ 所有的入口必须从一个代理(ProxyFactoryBean)开始
6 x' X/ R! _4 X' E2 g+ M: m 5 {. q; l2 D3 l: |, r" {9 h1 }6 j
1 D2 d1 Q; r' k+ A8 |5 `
3 P- b. q4 s+ N" Q5 k6 P3 V+ U K% G6 s
" n9 H% c- b3 N/ N3 i2 k( A9 P * c4 v0 A2 x4 Y$ n$ b0 l
3 ~3 i" }( g( t" H/ P& W
8 ^1 Z$ a7 W4 X/ S9 W" R1 I
expression=“execution(* com.javakc.aop.MyTarget.t*())”/>9 a6 }- e3 L% S9 ]
" |. ~; K3 P6 L1 ? p; s
; U* [' B3 u4 T6 P1 ]2 p( }! L; k
; v! K) s: o4 m ! y+ R4 H {( W2 O$ R: P( p
- z! x3 s4 l1 l5.3.使用注解的方法相对简单
( S" v" t8 z! [) p0 O0 r% P @AspectJ的基本语法
# i8 B- z! E0 V& X% l* p2 {. b/ U 1.@Aspect声明一个切面,将一系列的共同的功能定义成一个切面
9 {' K! ~% z3 j4 \" A+ _9 } 直接在类上定义@Aspect8 E8 k5 E& @7 ]/ X* e
2.@Pointcut声明切入点
/ K7 W+ _ s+ O8 t) |, O% U) W 2.1、用一个专门的类来定义pointcut,类中的方法名就是该pointcut的名字
. o% i' ?2 ]6 Y' D 2.2、可以使用匿名的pointcut
' s6 x, C% I7 T: I% C" `! i 2.3、执行切点的几种方法, I" n5 Z0 ?9 J! z
2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法
; n: y' N4 E3 ]/ M8 N$ a( | 2.3.2 within 指定到包,不能指定到类
h# h$ Y/ b( p3 o$ r within(”com.javakc.spring..*”)
2 C% S' T/ r2 P# w0 O0 y( W1 n 2.3.3 this 指定到实现接口的所有的实现类) d5 y- z+ W+ d$ h+ _) z+ I
2.3.4 target 指定具体的实现类* U& m/ `) p* Q T* P* ?3 I
5.4.advice的五种类型的示例
) W; Z5 M0 r6 M0 L( x3 E: X 客户端必须从接口走才能得到监控,实现想要追加的功能2 ^7 R- u$ ?& _5 h5 b
5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)' s0 s3 W0 G' K; i8 ~) d+ l
追加的方法的参数名字一定要与retrning的名字相同# G0 J* B: j% X/ V
在注解@AfterReturning中必须加上pointcut和returning两个参数
) M/ s9 ?) G/ h2 r z! D# U pointcut指所要监控的目标对象的方法
% r/ {% Q8 c* I 得到目标对象的方法的返回值,来作为参数,进行下一步的处理,参数没有顺序,按参数的名字进行匹配- D- |. Z1 m" o; L! g! X
完成追加的功能
\! E% x! T9 Y3 l" X 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
2 a; l5 A+ H, t ?' }0 J G( P J (1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
( y3 _# Y6 _ E; `: |" m2 c (2).8 g9 [1 q2 X! j+ j1 r$ t0 J
2.直接引用匿名的pointcut9 D( D7 o; J0 T2 y& R2 o3 e
(1).@AfterReturning(“execution(/ v2 l: h2 B9 v j% Z
* com.javakc.spring.schemaaop.Api.test4())”)& i7 t6 g! i' V6 d7 k5 O: W4 r
(2).@AfterReturning(pointcut=
' ^) @3 D: r; \- B/ P “com.javakc.spring.schemaaop.TestPointcut.t4() &&
0 i2 I( y' Y H* z! J args(str)”, returning=”retVal”)- H& @" Y. Y; f' E
@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)6 y* F" G6 U n
public void testAfterReturning(String str,Object retVal){
" N: r0 M& g4 T& P1 [& k+ A; y System.out.println(“afterReturning1=>”+retVal+”=>”+str);0 P& d* ?8 ], a0 r
}! k0 C# A" t6 z! Q
5.4.2.@Aronud: S+ ?" {- N( |# w& ?
注解@Around环绕追加功能;2 B# R* T# \! T# \3 U+ b% M( \
在执行目标对象的方法的前、后追加功能;
8 f( }2 {. U# D 必须有参数;第一个参数的类型必须为ProceedingJoinPoint;& I3 _# }+ Y. {; A
通过ProceedingJoinPoint的实例的proceed来调用所监控的
) z$ H& J) c, w1 \% @0 W2 d* m5 w 目标对象的方法5 B5 O, L9 O# U0 q! h B' O
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用% W- e6 Y7 P0 A7 L0 F
(1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
4 n0 n: C3 E. ] (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()4 ] G# f+ y7 C2 g. ~
&& args(str)”)8 D! e, U6 T$ Y/ m1 V7 g
2.直接引用匿名的pointcut2 ? V/ x* w! ?
(1).@Around(“execution(; O& i1 Q! q; ^/ W M" k
* com.javakc.spring.schemaaop.Api.test1())”)$ o% o, c2 m8 B" W4 B
(2).@Around(“execution(
! I5 C. R+ J2 U9 { R) G * com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)6 W2 ~7 o, n/ U6 \/ g/ c0 |0 [! X
// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
, t$ b1 `, ~% [+ g @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)4 n7 Z% F1 K# W* P8 ^! B
public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{, h' V) F; g+ C' e4 p g
System.out.println(“around1==========before1pointcut==>”+str)
p& A! r! N6 K5 V7 U Object obj = prj.proceed();* ]6 N; L/ u6 P4 t6 K3 h
System.out.println(“around1==========after1pointcut==>”+str);
5 i6 B( y3 E- Q' f. J- E }
# V: }8 Z8 [/ E 5.4.3.@Before
6 V! x& C3 I7 V m5 w# z* K 注解@Before在执行目标对象的方法前追加相应的功能
0 z7 d& q) u8 J9 g 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用6 c% h' Y5 \% \0 @; l4 C1 F* p
(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
6 i: t# D) U, S5 v D+ ~ (2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”): G$ W; ?) a% Z: P6 ^# d4 n
注意args后的名称与参数名相同
0 s; f9 |5 c7 g3 S+ f% k 2.直接引用匿名的pointcut
) i3 z. U. J! ?8 r4 V3 h (1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)6 f. L4 m A( B0 q7 I
(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)' o' d/ `& Y4 ~, q- h& Z
注意args后的名称与参数名相同9 Q' m7 x/ T s% f
// @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
- B9 ?! ~3 f9 t& ? @Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
1 U+ {: x4 W4 J9 N; P( M public void testBeforeParam(String str){! w- R9 ]& r, S$ c5 o
System.out.println(“before1=param=>”+str);
% Z$ A' ^ c+ l- y. G6 \6 r }
; O4 G0 t0 g3 Z3 V. \5 b ! \- o9 j1 A0 M! l' j
5.4.4.@After
' n( @" G" N+ a" B2 E 注解@After在执行目标对象的方法后追加相应的功能
, b4 V8 t$ \6 u7 c, A 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用$ X) U$ O( T7 z0 m
(1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
, N; \6 t8 x7 ]$ V0 w9 q4 @ 2.直接引用匿名的pointcut
# |4 f6 s' k1 A, r9 J (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)# N4 R6 m( G! O7 p2 k
@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
7 C. @/ h% ^+ q" Q0 d public void testAfter(){
r) h& _) ^$ K: @2 @ System.out.println(“after1== >pointcut”);2 z6 s& B& c- @; q3 D; T! H
}
, y- V# G" ^+ _2 `4 S% F, a 5.4.5.@AfterThorwing6 o3 q4 s2 P3 U u4 V3 I* I
- x5 d& |+ ^$ }4 i4 @- L/ u
C# c" j1 y# S8 `: L3 Z
- 描述一下spring中BeanFactory和ApplicationContext的差别: g+ `4 |0 f! V* y) Y# r% q# \9 ?
- k4 x' S/ x( ~; u
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; a1 W' j; U/ I3 _* V$ r! D
- 谈谈spring对DAO的支持$ V! E6 M: B6 _3 q9 j9 w c, O
8 l4 B% A1 s* _5 P
Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。9 p! b& b0 v8 o$ R# A5 Q- e' I7 D, j
简化 DAO 组件的开发。) v# ^; b1 u9 J3 Q( }4 p6 r& h0 Z
Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法,用来简化代码开发。8 @ E4 R& p t* Y4 J/ M
IoC 容器的使用,提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件,都由容器负责注入到业务逻辑组件中,其业务组件无须关心 DAO 组件的实现。
+ Z. `0 z6 b" m2 ?' ` 面向接口编程及 DAO 模式的使用,提高了系统组件之间的解耦,降低了系统重构的成本。" o, q g. P! q7 K
方便的事务管理: Spring的声明式事务管理力度是方法级。* j/ n' ~/ {7 Q* z
异常包装:Spring能够包装Hibernate异常,把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常,从而避免烦琐的 catch/throw 及异常声明。9 k ^6 a5 A d' ?8 \& g4 f5 |
- x! Q/ K5 ` @* n! M8 v$ x, b
; H3 b% b2 J% b2 {+ C. @- 谈谈spring对hibernate的支持
. I [/ A L' c- B& V3 H, V A. J, s8 x5 y' y+ U
在所有的 ORM 框架中, Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外, Spring 还提供了统一的异常体系及声明式事务管理等。5 } x0 u: Q# D/ ?3 E6 p
一旦 Hibernate 处于 Spring 的管理下, Hibernate 所需要的基础资源,都由 Spring 提供注入。Hibernate 创建 SessionFactory 必需的 DataSource ,执行持久化必需的 Session 及持久层访问必需的事务控制等,这些原本必须通过代码控制的逻辑,都将由Spring 接管ataSource, SessionFactory, TransactionManager等,都将作为 Spring 容器中的 bean。将这些bean 放在配置文件中管理。
- W- w* R, K; e! i 1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory,使得配置值很容易被管理和修改,无须使用Hibernate 的配置文件。详细配置如下:
0 L8 K+ v' n- v7 R
* W7 e8 Y" e! s7 F( r6 D class=“org.apache.commons.dbcp.BasicDataSource”>
# r" i* Z1 N! R- e& k 4 ~# _ X/ F: ~& h, x
oracle.jdbc.driver.OracleDriver# T. k: u2 |- v; O$ r! r
! h3 D4 E- W# l
5 p. t" E# {3 O d- g jdbcracle:thinlocalhost:1521rcl" X; X3 K4 [- J3 I( K. ^3 F! Y
9 L* D' ^9 Y) e! e9 F
! K2 Q% }7 W9 |% y$ n! }' w javakc2 J5 Q& z2 {1 L( a3 g
' ^) i6 b' y- I6 T4 G5 F* S$ S
$ ]) f3 l' _+ t$ ]5 y4 W' v javakc2
5 [; i o1 V6 }; v2 E2 i
h8 E' w4 Z9 T6 g
7 o, u0 E. g. c
9 Q6 Q3 P; J3 g- `) F V; d- ^ class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>& D$ Q* r8 H0 h: S- \0 J ?# h
3 a4 |% b7 `& U* Q, b4 D # [6 y4 K4 T2 k% e3 d
- x* E s% _. q; `! U
com/javakc/spring/h3/UserModel.hbm.xml
5 n* Z# s* P' E
9 D& O" R: D! z2 f; |! T* Z y+ }9 b2 J T7 m% |% G5 ?8 M" A
: O2 S' }8 b5 v% v 0 E. L/ E- v3 S; b. ^& L( ]$ _
hibernate.dialect=org.hibernate.dialect.OracleDialect' f& U) o/ n; J$ W; D2 A/ i
1 I9 ]) V/ h n/ y1 u/ l* W 5 J* y* m2 O# ]6 z. ~
@5 q. f! y' U5 e- {" l
% Y' B5 h) t% D- b$ V
; w- ~- [- A' r) n3 J2 N ) m1 H' n" a+ S3 F. r% }' }7 m" g6 ?
如果需要使用容器管理的数据源,则无须提供数据驱动等信息,只需要提供数据源的JNDI 即可。对上文的SessionFactory只需将dataSource的配置替换成 JNDI 数据源,并将原有的 myDataSource Bean 替换成如下所示: class=“org.springframework.jndi.JndiObjectFactoryBean”>! Y; O! \, H$ W% Z5 m4 P; B4 h/ s
7 L4 @+ h/ q$ _# O' x9 L
java:comp/env/jdbc/myds
$ X: C$ @3 V) X8 V2 ?
3 {- W, G2 s; X6 P. Q: m/ i 2、有效的 Session 管理: Dao类继承HibernateDaoSurport后,Spring 提供了 HibernateTemplate,用于持久层访问,该模板类无须显示打开 Session及关闭 Session。它只要获得 SessionFactory 的引用,将可以智能打开 Session,并在持久化访问结束后关闭 Session ,程序开发只需完成持久层逻辑,通用的操作则由HibernateTemplate 完成。 3、统一的事务管理。无论是编程式事务,还是声明式事务, Spring 都提供一致的编程模型,无须烦琐的开始事务、显式提交及回滚。 建议使用声明式事务管理,Spring 的声明式事务以 Spring 的 AOP 为基础。可将事务管理逻辑与代码分离。代码中无须实现任何事务逻辑,程序开发者可以更专注于业务逻辑的实现。声明式事务不与任何事务策略藕合,采用声明式事务可以方便地在全局事务和局部事务之间切换。 Spring声明性事务有两种配置方法,一种是xml配置:
* G6 u; U+ j6 i9 z4 s % v: }# I8 I& ]5 [3 z
) C4 Y& I( M) l2 n6 D, b1 W
9 H0 `& s# Y* g- ]+ [/ q$ D
" R: @+ B* D1 t% m3 g4 m2 D* f
9 _4 U& ]. X/ Y! M' L- D7 P * E+ i; A6 u5 K( S5 q' B- _3 A
% ?" [$ g# v" _. T4 V
) \# z& V+ W0 P: j |& x5 t
$ }- o* ?9 U+ B/ R7 t- [ 2 G( ?% `/ F* y' z' i2 ?
+ l/ p, a" g* f' y+ r3 ]
$ E' b b/ F' A& W- f, @
7 Y) Z$ `& ^# k7 s5 A 另一种是通过注解,在需要添加事务的类上注明 @Transactional " m# s7 U" [! P. z
Spring2.0之前事务的写法
5 `' c i' U5 [2 n- D; y
4 m3 G# F+ x( |% |6 f% c( l- d7 ]- R& B( ?# R% o* T7 r
class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”4 p# b& [' u6 `5 t! W' @& }( E
6 {' {7 R5 @7 r7 @' P% X& Z abstract=”true”>
6 Z; |% [/ L0 C
3 Q. T7 b. ~, N$ Y9 g3 F
! W* K/ V3 x7 ?* G, X; ]* O- D& z& F; r4 ?5 |+ x& c
7 e$ `% H2 v- W- [) k- h
PROPAGATION_REQUIRED,readOnly" E) R0 h! D% F( J$ l1 t
8 I; [4 d" o j W d PROPAGATION_REQUIRED
: H. W+ D8 n" [) s# O0 e2 L' ? S. O2 [* n( v+ p7 x
$ X( E" E8 M" Y$ K2 N% }7 r& V7 W
0 F1 p6 s2 F+ j2 H5 \! F; n& R0 [/ z. c z
|
2 _4 `/ s/ |5 h1 E
' t1 t- v3 `- P6 i2 Z- L# a2 q- 谈谈Spring对事务的支持1 m* I5 ~6 z2 k2 l* _8 C
7 c4 k v/ R* J. ^; {$ w8 M
, R; ?4 p, | m7 l/ A1、声明式事务管理:
1.流程:由客户端访问—-aop监控—-调用advice来追加事务 2.做法: 2.1 在配置文件的头中引入xmlns:tx 和schema的文件 2.2 2.3 注入数据源
) l2 M3 Z" S! [1 F: G( a
0 i* u: Z4 w2 p2 I+ m J
% C3 X5 ]6 c+ w( g) K2 @7 H# g% O' E# {9 r. |/ ?' g8 e: J
' w+ z7 m+ f. _; A+ f
2 |# D5 C. z0 q3 C" r y# v
2.4 由spring实现的事务管理,但需要注入数据源
$ t, M+ d7 Z$ ?) B1 y
- F) B8 X( [8 v& P( ?2 h% X/ U) f b! H! O
2.5 事务监控所有的方法(事务加强)
7 _5 U6 N( [- i) S G% V7 N
/ {# N! q7 y( x+ z
% R7 \, O: [6 p! J7 K- {* P! x) ^* N- @- [! X; ?
" W7 _4 z- {2 c" B2.6 定义切入点 ) M0 l4 ^1 n2 C+ p: P
( Z( P# r' ] O) m& z1 F! s0 j
4 u+ h; J9 i& ]
% n) Q' E3 X7 c* D6 M
$ Z7 A$ P# D7 e' g" T2、使用注解实现事务管理: 1.注解@Transcational (可以在类上,也可以在方法上) 2.在配置文件中同样需要注入dataSource和spring的事务管理 3.使用注解的方法来追加事务 注解驱动
1 N, p% ?* n- @# G7 |$ |% [. n. F* A6 [3 A6 x) u8 E
如何在Spring中使用Hibernate的事务:- r, }/ W; A, J; y4 h
4 [; y- d) K2 J; [# ^* y
1 W+ W% l/ @ I
& w- d5 q- ?# |) R0 Q0 v d
如何在Spring中使用JTA的事务:& g; ?; N. o% x8 j6 ~
/ w. R2 z( H6 B6 X; ?6 c5 d7 h+ {% `
|