Spring
* {) j. y$ R$ R. I9 D; N! z- 是什么?! Q& e n3 h0 Y: s
; m# b. [8 x3 x: S6 B
Spring是基于JEE的轻量级的应用框架
" I8 a( |1 v, E/ N! q2 N4 J3 @- 有什么?* `% `- J- o5 x6 D; R
1 _. v$ b% c: C9 T3 X. q
% R$ d5 u+ z' d& g. r
每个包的功能: Spring MVC:spring 本身提供的web 框架 WEB:集成其他的web 应用的框架,或者说是对其他web应用框架的支持。如struts,webwork JEE :集成一系列的jee的技术(对JEE技术的支持) DAO:封装了JDBC;(对JDBC的支持) ORM:提供了对ORM工具的集成(支持) AOP :面向切面编成 CORE:spring的核心包,提供bean的工厂和IOC容器 + Z: `3 I& a0 Q; N+ F( h" P! A
- 能干什么?6 J9 t9 l8 P* v. M8 J% Q+ l
: r! e, H" A" z2 ?. ^' q* |" l2 z
把一系列的jee的技术有效的组合在一起形成以良好的系统 + B. U P: l; ?/ u8 T
- 怎么用?! @/ c/ E* |6 `, \5 ?) V! K
; ]$ c. \$ Q. y
- 搭建web工程,引入spring的jar包
+ C( v* V6 y& T- ] - 在web.xml中添加如下配置
% B; B; w" Z9 u6 B, k4 g& b, @, j) \6 }
( y& O+ u$ @$ ^& ~& Y j. O6 e
2 i" y4 K% N4 T: Q
contextConfigLocation$ ~: b# p/ c, ^9 g/ J
classpath*:applicationContext*.xml# c& _. F( J2 g- w0 i
6 E0 i* `% }' s# X; n
" m; p. D, H- u2 M struts2
. ?( q. _9 T8 {6 y! ?8 K
+ u. e) n1 Y% M$ P: l org.apache.struts2.dispatcher.FilterDispatcher
0 Z* _/ ]! I9 x# [5 s* J7 O' L
6 ^9 d, N5 J) `3 C7 J P, R+ c
* V' B, q5 H! H
" f% Z @, i( m4 O Y struts2- z7 v& {$ B/ m8 I: ?: N; Y
/*0 X& {7 |2 @! ~0 J0 l0 r
( J" s2 t& x/ b2 n$ n
1 s- `) q7 W: t$ P. r, g1 y
3 F- h) j8 e+ l& Z) _
org.springframework.web.context.ContextLoaderListener
" G4 l( T* P3 Q! ]( |9 |. {
1 o5 [$ R& z. `9 \, ` - 部署/ @0 T8 B2 E$ Y. g
2 v% B/ C4 r* @* X. g
! u7 `* y0 y/ ?* g6 s7 W
2 p! | B* ^& C) p( W1 p5 Q
1 v/ Q, Z H4 O5 w$ B/ @7 V6 x, z% Z- 容器和bean
2 D: Y: J" V6 b" e/ a' q; v
Bean :是指受spring的ioc管理的对象称为bean 容器 :(与jee的容器类比) Jee :提供组件的运行环境和管理组件的生命周期(不能单独存在) Spring :提供bean的运行环境和管理bean的生命周期(可以单独存在)
7 W: p s7 j7 {8 W6 E2 r: ]. p: Q( Z! m* [- X9 W! m3 n0 t1 A( ?' ]0 k
- DI依赖注入
* i b5 ]: ~8 G; d: [8 \3 h Y
1. 应用程序依赖spring注入所需要的对象 IOC和DI是对同一种事情的不同描述 2.setter注入: 在配置文件中将接口的实现配置为bean在应用程序中注入bean 例如: 在配置文件中
& J& Y' ~' @* v; Q. b+ V
1 S/ e6 w a3 W, u' U! I4 K" ~0 _8 U) R' P% I
在应用程序中 Public DBDAO dao ; Public void setDao(DBDAO dao){ This.dao = dao; } 3.构造器注入 $ {; j% p( w! _
4.ref 表示参照其它的bean 在参照的过程中一定要注意死循环 5.自动装配———–〉no 自动装配根据名字来匹配相应的bean 尽量不要去自动装配 6.lookup注入 7.singleton 1.单例模式是整个的jvm中只有一个实例 2.spring的singleton是指在spring的容器中只有一个实例 一个生命周期中只有一个实例 8.DI的优点: 1.程序被动等待,强化面向接口编成 2.切断了对象或组件之间的联系,使程序的结构更加松散,运行和维护更加简单 4 W3 W% w4 o3 S1 C
- Aop面向切面编程
' U" z1 q! ?9 z/ `& o
6 y3 U0 R# I' E& Y
1.AOP面向切面编程 一些较好的模式或者是示例—-范式
9 N* y$ G' X+ }, _6 i% @% ` 切面:一个切面代表我们所关注的一系列的共同的功能点(模块之间的共同的功能点) 2.AOP的思想: 主动—->被动(追加功能)- |, @6 Z! y1 n$ R) j! Q
3.AOP 的概念4 O' I8 \' |4 [/ ?! y2 j
1.切面 :我们所关注的功能点 2.连接点 :事件的触发点(方法的执行) 3.通知 :连接点触发时执行的动作(方法) 4.切入点 :一系列的连接点的集合 (连接点的模块化) 5.引入 :扩展的功能 6.目标对象 :包含连接点的对象 7.aop代理 :实现机制 8.织入 :把advice和目标对象连接起来 4.AOP的事件机制
" i( a0 K: R- N. d) [8 O+ b 1.通过切面找出一系列共同的功能点 2.找到目标对象(在标准的spring 中 接口的实现类为target) 3.找到切入点 4.确定连接点 5.通知spring AOP,查询xml文件,通过代理找到advice。 6.由aop代理来实现动态织入
! U1 s1 ^" a* ` N9 `5 ?; l; E5 s
' R. }" v2 h P9 G+ C! B ^
. t0 i) G- O4 B8 }% t* \" h' m- Z
! a& h- G9 e& Q7 e/ H: I0 Z" v+ p3 ^; S
3 o3 l" c6 s* v8 ^
7 I* O% J5 z1 S6 m$ r0 h: e5. AspectJ
1 j9 q% N! v. w% d% B7 A 5.1.在xml中配置比较烦琐
# e0 p) D1 N; P+ L; g 所有的入口必须从一个代理(ProxyFactoryBean)开始- s/ y- O& u8 \/ B( j
8 [* [' s# c/ M: r' n
$ |% \0 N1 o: t' G, q
+ H$ P2 X- I$ H( n, t6 j; \# @7 v8 m# g5 T% X3 {
; [" G% F5 L2 e5 F+ u: f; _
: W, Y9 L0 i( I
! b% L$ C: p0 r" B) o
* ^7 F' N8 K* jexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>% _& n# b3 O# X
. J! m9 l8 h1 i& p* n5 U3 }( B/ f
. K$ Y& V4 Z5 M. {7 b8 f6 Y 3 `% a& p5 c7 B. O2 p) f: J7 T" j$ h' {
4 E9 t" {" U! `* F4 Z
* k g7 N0 [5 M; p: l6 Q8 ~) x5.3.使用注解的方法相对简单
: r) d. y5 D2 i s6 _1 G# n, j- ^ @AspectJ的基本语法
0 t& t- o9 c. ?/ i# y# l9 t 1.@Aspect声明一个切面,将一系列的共同的功能定义成一个切面/ c* {: |5 H& `- r) W6 H
直接在类上定义@Aspect7 M1 F0 k+ I, B5 T0 N
2.@Pointcut声明切入点8 `( F$ m( q1 A, y5 t
2.1、用一个专门的类来定义pointcut,类中的方法名就是该pointcut的名字
/ ?7 N' w$ \* j2 C1 P7 S 2.2、可以使用匿名的pointcut0 g% X( v' ^, A, B! `* @
2.3、执行切点的几种方法 `/ U [: U. u9 d; J) U4 ~+ I
2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法7 ?7 `5 r' _5 f: b0 T o b# K
2.3.2 within 指定到包,不能指定到类
, T% L- F b3 n0 W+ i1 L within(”com.javakc.spring..*”)9 p' J, N# f! l# N: u! ] n
2.3.3 this 指定到实现接口的所有的实现类0 f0 g; Y1 l( a8 v; O% R D$ ^' d
2.3.4 target 指定具体的实现类
9 k& x! Z v0 a5 S( D 5.4.advice的五种类型的示例
5 [! ?2 N+ }$ m# i+ E 客户端必须从接口走才能得到监控,实现想要追加的功能
1 D8 r A: \ w$ o) p6 |5 q 5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
2 M1 V" C, [: a8 t! l9 v+ W 追加的方法的参数名字一定要与retrning的名字相同3 @6 ?: ^/ v. t3 J& R+ i
在注解@AfterReturning中必须加上pointcut和returning两个参数
+ k3 B- O# ~) L( L1 k pointcut指所要监控的目标对象的方法
# s% @4 U% `1 S# b 得到目标对象的方法的返回值,来作为参数,进行下一步的处理,参数没有顺序,按参数的名字进行匹配6 c$ V; ]4 ]) F* }, o" I7 h7 \
完成追加的功能
8 i3 u/ F& e, G 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
3 E4 e3 x+ R d* r (1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
* T1 A5 `4 D9 S: N* t& ? (2).
* O1 u3 c/ C6 H) R 2.直接引用匿名的pointcut
' F! g; b; A1 K- ?. k9 \ (1).@AfterReturning(“execution(# f( X) ]/ o9 m
* com.javakc.spring.schemaaop.Api.test4())”)9 Y1 a3 V( m. P5 R' Q8 w
(2).@AfterReturning(pointcut=
: N* ]% W) S3 _. u5 c( r# t4 X “com.javakc.spring.schemaaop.TestPointcut.t4() &&; p+ D9 m' Y" G& W' `# p
args(str)”, returning=”retVal”)
. L+ q0 E" ?" Z5 C" x) M @AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)0 x8 X1 p/ D2 X( E* f! Y7 }% {
public void testAfterReturning(String str,Object retVal){
$ n9 D# a" S' Q$ j5 E System.out.println(“afterReturning1=>”+retVal+”=>”+str);7 B" D$ c; s3 Q2 F6 f7 p
}
7 A( I2 n3 I* E: U( L 5.4.2.@Aronud
$ J" {- Z# |( L" w3 Y 注解@Around环绕追加功能;% e' \' O1 Q6 n3 n/ y
在执行目标对象的方法的前、后追加功能;3 d. s# c2 ~4 [9 \+ d1 K0 b
必须有参数;第一个参数的类型必须为ProceedingJoinPoint;6 c" |* ^/ s7 {; F" Z" m3 a
通过ProceedingJoinPoint的实例的proceed来调用所监控的
' U; Q. ^& l2 _, C+ _" l5 | 目标对象的方法% n$ |/ n1 K) x) n4 k7 i. `
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用' Y: h: k. _ a5 F7 a4 R
(1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
3 W. o- m' b1 B( e' c (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
% e0 K8 e+ N+ _, `1 a && args(str)”)5 I) w' I' N% S8 A" G3 y
2.直接引用匿名的pointcut* s' i1 C0 }: p" _" i& [
(1).@Around(“execution(
9 U. U4 v, _8 p; J. F * com.javakc.spring.schemaaop.Api.test1())”)4 D+ k r9 i: ]6 B
(2).@Around(“execution(
: \: {0 w9 j$ n# p * com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)6 j' T! O* J! r+ D! g3 U
// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)3 `6 ]: B% b4 W% N; W' V
@Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
q# `) V1 B, V9 A; ` public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{7 m! l4 j* }* T0 X
System.out.println(“around1==========before1pointcut==>”+str)
7 ?' l$ m- K6 J, m Object obj = prj.proceed();9 V) q$ D7 v& H* d! ^4 r1 A
System.out.println(“around1==========after1pointcut==>”+str);
# ~# i. Q6 u0 ~& i3 U9 W }% h- G' J5 }5 O0 _
5.4.3.@Before
' Z! W! W. q x# z$ D' m3 g 注解@Before在执行目标对象的方法前追加相应的功能
5 p! V }/ U1 `, y! o2 p: m( e- C 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
/ F! h0 y; p8 x# W! q2 g( j (1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
5 X, S$ o, z- r! g (2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
$ G- n5 \4 n" a4 Z! g/ ^ 注意args后的名称与参数名相同
# A- W2 [( ?. S) L 2.直接引用匿名的pointcut
! G6 L* O: n- }/ K- ?# o (1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)- E; I1 b4 o- `& V
(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)) ^/ d! u- I! e/ G, u. O
注意args后的名称与参数名相同
4 m3 y6 H I8 ^7 _$ b; r( _ W // @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”). h# h0 ?* g" O, P+ v6 i
@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
, t% j2 r5 v7 m/ i# L public void testBeforeParam(String str){
% ~( F' r# |1 J. B System.out.println(“before1=param=>”+str);( i7 q# Z! ^$ d) j" l
}2 `1 }: A& k: B3 Y
" \6 F" S/ z7 J2 M5.4.4.@After% h# S- D J8 V2 W$ Z3 p, R
注解@After在执行目标对象的方法后追加相应的功能! `. g3 I/ V7 |- \0 s( z4 G0 m" U
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用: O- J* b% ?) K0 s+ c ?
(1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)5 U) y4 ]# x8 X3 y
2.直接引用匿名的pointcut
4 t+ l. h, @" P- z& P7 G6 { (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
* @+ W H& j" X% l- z @After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)9 V0 x; u6 h. |1 [1 r7 D& X: d# m
public void testAfter(){
2 {/ \6 Q1 t3 _( l" A6 F System.out.println(“after1== >pointcut”);* q7 R. B- d4 S, T: a
}' h! Z% W2 M7 P' q4 @
5.4.5.@AfterThorwing
8 Y ] ~6 t% @8 F 9 c" E* s U$ Y* P
: |% m4 y. f2 y9 Y$ E2 }; i- 描述一下spring中BeanFactory和ApplicationContext的差别* |4 w1 w1 E3 @5 W, X
: q/ a& k& \; |9 {# p. {$ J
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”);
3 Q1 d9 [! e% g- 谈谈spring对DAO的支持; o% v) ^2 ]1 r- {6 \ K) Q( _' ~
) F; K% ?2 m5 k" [& v
Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
2 \% }) u% x! `( S 简化 DAO 组件的开发。
8 e* o, a/ Y5 p9 o& TSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法,用来简化代码开发。
- m: O. b# ?; g6 } IoC 容器的使用,提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件,都由容器负责注入到业务逻辑组件中,其业务组件无须关心 DAO 组件的实现。
( D9 v1 D3 A2 O; W7 x3 l 面向接口编程及 DAO 模式的使用,提高了系统组件之间的解耦,降低了系统重构的成本。
+ `( N6 e6 v4 O" E) Y 方便的事务管理: Spring的声明式事务管理力度是方法级。
6 g1 L8 A5 S1 U4 C$ V 异常包装:Spring能够包装Hibernate异常,把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常,从而避免烦琐的 catch/throw 及异常声明。$ m2 E$ @) H( i
- K) G7 g8 q- j" ~# R: f2 w; r. _" b0 N$ K6 W
- 谈谈spring对hibernate的支持
, o0 V8 Z$ z1 F$ W* l+ C. i7 ]6 S" Q; |+ |
在所有的 ORM 框架中, Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外, Spring 还提供了统一的异常体系及声明式事务管理等。
# R% T7 _8 u5 H' a$ U; R 一旦 Hibernate 处于 Spring 的管理下, Hibernate 所需要的基础资源,都由 Spring 提供注入。Hibernate 创建 SessionFactory 必需的 DataSource ,执行持久化必需的 Session 及持久层访问必需的事务控制等,这些原本必须通过代码控制的逻辑,都将由Spring 接管 ataSource, SessionFactory, TransactionManager等,都将作为 Spring 容器中的 bean。将这些bean 放在配置文件中管理。
) B, L" L% k6 w$ h% d 1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory,使得配置值很容易被管理和修改,无须使用Hibernate 的配置文件。详细配置如下:! @7 j2 j) p3 R, C1 [- `, i
1 I0 a% O: d0 r' q
class=“org.apache.commons.dbcp.BasicDataSource”>* w' R7 ?1 }7 T7 X Y7 S. Q, B |
- `/ v/ l% R* d. O+ R0 T. V+ }
oracle.jdbc.driver.OracleDriver1 X5 W; S; j, ~; a) l, `6 d
( ~' A4 ~6 H0 W& `4 @$ t& V ) p3 z7 U- v+ h( O* \
jdbc racle:thin localhost:1521 rcl
* r( e( f4 I' \2 b ' t8 j( h' Z6 o% M( r& s' e
7 G( C k$ K1 @% V$ w
javakc2
! J/ Z& G3 d* |. ?
( @' ?: ~) p/ M3 B n
4 G& N( v( k. N9 h javakc2
3 Q5 ^; L6 b, ~/ |. U9 f* i7 p/ {- \
4 M$ t$ \9 L B/ m3 }
! i* D) I A9 J; @. p' O3 S ) ^; l& k/ D0 \$ _0 d. y; ^
class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>) l8 o+ G! x' y- s5 ?
1 K9 v _! S7 C5 T
7 U1 O) h- q7 E; P# L. v% G ( p5 O; C& I3 Q# ^
com/javakc/spring/h3/UserModel.hbm.xml
/ u, ?7 }2 e' J9 Y
% z$ [6 y+ n$ V$ n7 t8 ] $ A6 j( V8 [/ c) H
) a: w# D! y- k. z3 d' w# } ; s7 o" \2 f1 F6 I( j" C4 K/ M+ z
hibernate.dialect=org.hibernate.dialect.OracleDialect- V) i" W! t8 d
. U @6 f3 K) t. Z+ q- a8 K
# P, x+ X- T# {+ k; a3 I% U
) E4 H" E3 ]* O. h7 }/ A) U
' b4 }! K, j8 p% K
: W+ ~$ y7 p* K8 r( t
/ R5 m8 c7 R/ n( l F# B2 I7 r, ? 如果需要使用容器管理的数据源,则无须提供数据驱动等信息,只需要提供数据源的JNDI 即可。对上文的SessionFactory只需将dataSource的配置替换成 JNDI 数据源,并将原有的 myDataSource Bean 替换成如下所示: class=“org.springframework.jndi.JndiObjectFactoryBean”>
8 P& W% _9 d: Q( w+ q " ~+ o( X8 N- ]8 l- \0 {
java:comp/env/jdbc/myds; z) T; ` Y: j. q
6 t; u7 V9 q0 O, l p' g4 c
2、有效的 Session 管理: Dao类继承HibernateDaoSurport后,Spring 提供了 HibernateTemplate,用于持久层访问,该模板类无须显示打开 Session及关闭 Session。它只要获得 SessionFactory 的引用,将可以智能打开 Session,并在持久化访问结束后关闭 Session ,程序开发只需完成持久层逻辑,通用的操作则由HibernateTemplate 完成。 3、统一的事务管理。无论是编程式事务,还是声明式事务, Spring 都提供一致的编程模型,无须烦琐的开始事务、显式提交及回滚。 建议使用声明式事务管理,Spring 的声明式事务以 Spring 的 AOP 为基础。可将事务管理逻辑与代码分离。代码中无须实现任何事务逻辑,程序开发者可以更专注于业务逻辑的实现。声明式事务不与任何事务策略藕合,采用声明式事务可以方便地在全局事务和局部事务之间切换。 Spring声明性事务有两种配置方法,一种是xml配置: ' a9 ]4 W: B- [& ^8 U: f
2 B' x* y+ h {7 z) I. h) w9 [0 _1 \ " [7 e9 Y# \; j( g0 B P
0 `& l4 C3 {# q0 S& O, J" O; H! E: [
- O8 ~4 b* u+ O% r( r
- p& Y" p0 B+ f7 L- ?- V5 e( [
9 X5 ]/ D8 g3 U: e; o, ]: L
4 _7 [# H3 T' H5 B5 m1 ]; G ) u" z& t [; ?% p& I
+ E5 Z( {, q6 J, K0 c8 H; Q
3 J8 H2 [- J9 d1 ~! Y( @' X7 X& t ?5 h, G2 T! @6 U
2 \" g2 k$ Z$ N h3 S/ I
. s' D1 H% q0 q+ N( B 另一种是通过注解,在需要添加事务的类上注明 @Transactional P$ i: i% o6 e8 V5 A: x
Spring2.0之前事务的写法
6 N% |. u% A& {, \4 }% \% K
' d. ?) f) E3 m: I& x8 z" |5 X# z
u* ?1 e( ^& U- L class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”
) i2 y; E; B6 H! |$ Q" u. `$ T& O
- d* c) S! K4 G abstract=”true”>7 M; T( V: o% X! S0 U) N! |
" t* ^" c% p+ S: L/ C
( N5 j# X% J' \+ c& g
3 V& T- ~0 b0 n. Z' r0 f' X
2 w. d6 `3 N0 `5 f( ` PROPAGATION_REQUIRED,readOnly! O9 H0 n, L! `
- D/ v5 `6 k1 i! B1 n3 n
PROPAGATION_REQUIRED, s1 p/ ?; S5 v1 C' t7 b; x
/ U, w# s8 t2 t; T. J
0 g: s4 @, }. i9 l, |4 Z8 P% f* D# r! p2 Y
$ e# T& ^' y, ~% W$ F" b: | | / r+ {' P. }+ D7 g# _- Y- Y
* h S4 B2 p( q y- 谈谈Spring对事务的支持
5 x" n v: v, u: ^ s/ `6 |' P& R1 b8 z' u/ |! T
4 B0 g5 @# w; a
1、声明式事务管理: 1.流程:由客户端访问—-aop监控—-调用advice来追加事务 2.做法: 2.1 在配置文件的头中引入xmlns:tx 和schema的文件 2.2 2.3 注入数据源
0 j- u6 J( m0 P" ^) `$ z
! x# a% K* r7 v6 h% l/ t! H/ k% ?2 ^. g/ m, `0 h# ?) D* s7 |! b# Q: j
$ @$ g, l( d: C
- m8 W: ^) I1 a) F3 Y* ^1 R
, s% |1 b4 F6 P/ [- W6 h, }
2.4 由spring实现的事务管理,但需要注入数据源 8 n2 [8 H& ?6 y
& U% E) d& Z/ W7 z+ [- X
) a: j3 q2 W" O8 x& t6 r8 D2 m! h2.5 事务监控所有的方法(事务加强)
( ?! q: L! D9 |! Y% ~/ t# U% l( k9 `: ~6 n0 F0 e
, J4 M) t! k) C
5 K; t+ n: ?* m9 b3 w, u
4 [& L! O* D* ^& O% B2.6 定义切入点 0 ` D- Z9 v# {4 [% }' C
1 h3 a7 [) J, E5 ^
& F6 g" ]# Q2 H6 W w# g+ [; ]) M. Y# Q, b, R) H- |
, t) ~* a X }1 X
2、使用注解实现事务管理: 1.注解@Transcational (可以在类上,也可以在方法上) 2.在配置文件中同样需要注入dataSource和spring的事务管理 3.使用注解的方法来追加事务 注解驱动 9 c) l: G! u: Y3 K- K7 j: \: s
, l) n- I$ i0 D& J& X如何在Spring中使用Hibernate的事务:( M9 e" M! |7 l$ T+ D
, z0 `5 w# Y' C& d; t2 R- b
0 E# M; X ?2 w" N$ @9 p$ E( k / e) \9 Q/ J6 F% h% U
如何在Spring中使用JTA的事务:" q9 t% s, E: I" ]
5 [9 ~8 R" U! J2 l2 B: D$ C
|