Spring
- t7 E3 O' N) r: }- X7 C1 n9 J7 [- 是什么?
0 l1 {" L0 i e4 f+ g# ^; J6 K# V {, X' a) k* H
Spring是基于JEE的轻量级的应用框架 9 e0 @1 G4 D# ]: C
- 有什么?% Y4 ^ e6 D: Y% `5 u
2 `0 I/ ~4 ^* b0 `# ?
" ^3 n Z! A0 e
每个包的功能: Spring MVC:spring 本身提供的web 框架 WEB:集成其他的web 应用的框架,或者说是对其他web应用框架的支持。如struts,webwork JEE :集成一系列的jee的技术(对JEE技术的支持) DAO:封装了JDBC;(对JDBC的支持) ORM:提供了对ORM工具的集成(支持) AOP :面向切面编成 CORE:spring的核心包,提供bean的工厂和IOC容器
( ?* } I& j( ]- X9 n* o9 y8 G. f- 能干什么?. L( W3 Y4 ~, L2 g% S) j
' ^& G. m1 s$ a1 A- _( a: ^7 P
把一系列的jee的技术有效的组合在一起形成以良好的系统
% i: U2 ~6 P4 t, `; k# n% ^! P- L- 怎么用?$ A" g$ P7 n2 E& Y! S
9 {) R$ g: i$ g6 ?2 t, g4 T- f
- 搭建web工程,引入spring的jar包
2 S- }; d2 ^% }& N5 Y& d - 在web.xml中添加如下配置
( S( L9 e* O# ~ @: ?8 Y& k6 }& T
- g- l4 r( @* I F9 \
/ a j# M9 @3 L: g; K
2 S4 [5 X/ E. g/ Q
contextConfigLocation
* W* t: r# I1 y+ i' q0 k9 R& X classpath*:applicationContext*.xml1 D3 ]* H5 {2 z3 z# ^
7 J0 {" E- s3 b6 g8 ]
" j1 `3 A8 K7 i j- {# _* {
struts2% K; _5 ]4 y: K/ n( i4 T! t
. y( d; ~* [( F org.apache.struts2.dispatcher.FilterDispatcher
% |; b9 l4 T2 P/ `. L* v8 ` i
2 ~, m6 G1 H* |; Z. l: B. `6 g/ | 9 O8 I3 J) _$ }8 j9 w; Z# D7 Y
4 y. ?- S, F E5 \ struts28 E4 Q, c- Q. ^7 t7 K. z
/*8 @8 C, ]4 ]' a( t$ S+ Y7 }2 F
) U9 @' v4 r+ [! Q7 O
$ Z$ \: K) A" f0 h1 R: ?3 L3 B! g
. w/ Y& e0 j5 G org.springframework.web.context.ContextLoaderListener
# }4 |0 ?3 @' {- m" a# c$ a 8 ^- W {1 i. Y& l% }9 J
- 部署
' L4 i* ~: _; Q. D Q* {+ Q
/ K' y1 k4 s2 W3 X 8 p% n5 g3 L- T. c6 {
$ [+ q3 n" q N2 t X" J7 n6 v( \2 H. _3 o, R
- 容器和bean
, s: C0 u* O* q$ B* V: ]! K; l0 D5 j" e
Bean :是指受spring的ioc管理的对象称为bean 容器 :(与jee的容器类比) Jee :提供组件的运行环境和管理组件的生命周期(不能单独存在) Spring :提供bean的运行环境和管理bean的生命周期(可以单独存在)
s r" K' x& ?8 \: w" I9 Y
& f% n; V$ t8 k4 b" ^- DI依赖注入
8 S4 N: K4 q7 i3 n. h) G
1. 应用程序依赖spring注入所需要的对象 IOC和DI是对同一种事情的不同描述 2.setter注入: 在配置文件中将接口的实现配置为bean在应用程序中注入bean 例如: 在配置文件中 ! F0 Q8 \1 e7 K. A; U5 k
- Q. I/ r$ a" \$ t# J/ m, b
9 Z& s# G% E \" j' ~( W
在应用程序中 Public DBDAO dao ; Public void setDao(DBDAO dao){ This.dao = dao; } 3.构造器注入
" F+ n" {- ~7 _9 \4.ref 表示参照其它的bean 在参照的过程中一定要注意死循环 5.自动装配———–〉no 自动装配根据名字来匹配相应的bean 尽量不要去自动装配 6.lookup注入 7.singleton 1.单例模式是整个的jvm中只有一个实例 2.spring的singleton是指在spring的容器中只有一个实例 一个生命周期中只有一个实例 8.DI的优点: 1.程序被动等待,强化面向接口编成 2.切断了对象或组件之间的联系,使程序的结构更加松散,运行和维护更加简单
$ p, v0 Q% \+ R# C1 T `% Z4 T- Aop面向切面编程 v/ p2 V( H( z5 `
2 e& A6 l: f8 ]& y" ?
1.AOP面向切面编程 一些较好的模式或者是示例—-范式
9 M2 h1 `+ F; d" A# \; T' X( ?/ H% i 切面:一个切面代表我们所关注的一系列的共同的功能点(模块之间的共同的功能点) 2.AOP的思想: 主动—->被动(追加功能)6 l7 S) c1 C( g* z: x& W& W
3.AOP 的概念
8 H% ]( v/ ` P" k: g0 k/ D' O! a 1.切面 :我们所关注的功能点 2.连接点 :事件的触发点(方法的执行) 3.通知 :连接点触发时执行的动作(方法) 4.切入点 :一系列的连接点的集合 (连接点的模块化) 5.引入 :扩展的功能 6.目标对象 :包含连接点的对象 7.aop代理 :实现机制 8.织入 :把advice和目标对象连接起来 4.AOP的事件机制
2 T9 X7 b# Z3 z 1.通过切面找出一系列共同的功能点 2.找到目标对象(在标准的spring 中 接口的实现类为target) 3.找到切入点 4.确定连接点 5.通知spring AOP,查询xml文件,通过代理找到advice。 6.由aop代理来实现动态织入 . O9 J& F+ r7 y: m4 n7 E6 y
/ f1 C2 n; Y; ]3 }
( L0 P0 U5 k9 e& |
$ `2 w5 o6 w3 Q* N/ e
, a/ {: v# I- T0 g# d; \, P2 }. H& z+ Y' L7 y4 I& j0 K/ M
! b2 y8 r5 l( r6 c, S
5. AspectJ
% X4 {! I4 Y$ ?9 ^) O 5.1.在xml中配置比较烦琐
# Z8 f, m* Q4 z 所有的入口必须从一个代理(ProxyFactoryBean)开始# v, ]# O# a7 g; K6 q; E
( j9 @ `$ Z9 l, I6 l7 ? Z$ C
/ k2 y: x: r5 C8 O, a
# L. ]. c& E6 _% V! W6 G |' N; z' t+ \! e& L9 A) _
* b5 u6 D3 G, z 9 c Z. L, `$ x" t- h
9 n! h2 R: c8 v9 V" Q/ ~4 D 9 `5 P% l$ s( R
expression=“execution(* com.javakc.aop.MyTarget.t*())”/>. _- R" t/ m& M5 _' M- [& G
! c2 R% @+ W: `
( R4 _ T1 F% |* Z/ `7 f) w+ t
$ c$ c; O( H4 K3 W 6 l: x( ]% W) K' q3 ]2 Z$ q# b
3 B+ r- l8 b4 K5 Q8 w# |. D0 e
5.3.使用注解的方法相对简单7 ]5 x( q) V; ^$ M
@AspectJ的基本语法
0 B4 c( C/ N3 @+ Z3 C3 W. C 1.@Aspect声明一个切面,将一系列的共同的功能定义成一个切面5 ~6 r9 L& q; s
直接在类上定义@Aspect
. t: Z" H3 H& r 2.@Pointcut声明切入点
& ^' v- u! v# `- Y: P6 O7 u 2.1、用一个专门的类来定义pointcut,类中的方法名就是该pointcut的名字' A( \, n0 C. _4 y8 i
2.2、可以使用匿名的pointcut _$ \' ]; W6 k. Z
2.3、执行切点的几种方法0 T2 M3 z/ c) j
2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法
9 i' ]3 ~5 h2 [( P 2.3.2 within 指定到包,不能指定到类
9 S. g! Y' g7 e3 B# b within(”com.javakc.spring..*”)
5 Q1 a( u4 b# v; } R& A3 a& | 2.3.3 this 指定到实现接口的所有的实现类0 T; e3 F" W# Y: t. e
2.3.4 target 指定具体的实现类
2 i7 z( O* C& D3 @, K+ c& U3 x 5.4.advice的五种类型的示例
4 X _6 f5 U& }2 y 客户端必须从接口走才能得到监控,实现想要追加的功能
" a; y' N+ c; \- ^# M 5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)7 o2 r% i. i. j$ N: C. L
追加的方法的参数名字一定要与retrning的名字相同2 u: R* z3 f0 m' C2 V& N) P
在注解@AfterReturning中必须加上pointcut和returning两个参数- U3 j1 T9 {. J6 M9 g
pointcut指所要监控的目标对象的方法
! m5 R" q! w9 ^/ @+ w! Z 得到目标对象的方法的返回值,来作为参数,进行下一步的处理,参数没有顺序,按参数的名字进行匹配
& } d$ R* C* ?/ P' [ 完成追加的功能
& j; n/ B f8 a& y 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用/ u1 X7 m% ]2 U t" C
(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)3 z- s! l+ V7 g% I7 p# D3 m
(2).) v' @( p8 n* v6 E1 P* l
2.直接引用匿名的pointcut
: _4 f# K/ `& U" ` (1).@AfterReturning(“execution(
% y1 S- m8 l1 k# G * com.javakc.spring.schemaaop.Api.test4())”)* b: `* Y% o K* p
(2).@AfterReturning(pointcut=
" g8 d6 J0 f) c0 P4 F “com.javakc.spring.schemaaop.TestPointcut.t4() &&
& x2 ^7 t/ ^& }# W( r args(str)”, returning=”retVal”)
# U' \( `# q& W @AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)* f1 ]' J7 Y& ^7 ^1 l# J" H
public void testAfterReturning(String str,Object retVal){
0 C2 \ ~+ ? h9 _# [* b- p5 `' J# J System.out.println(“afterReturning1=>”+retVal+”=>”+str);# W5 ] ^1 w% W
}8 V5 S* P2 r) X8 |$ N' [2 \) B
5.4.2.@Aronud8 K' h6 `+ v, k
注解@Around环绕追加功能;
3 A1 O2 J4 {8 @; h 在执行目标对象的方法的前、后追加功能;. O) ^4 X8 X' h7 v: d, u, x7 z
必须有参数;第一个参数的类型必须为ProceedingJoinPoint;, o6 |( z- V- P, j
通过ProceedingJoinPoint的实例的proceed来调用所监控的: x* ^) u8 ^2 j! z
目标对象的方法& L7 a2 H7 _5 @ t i/ W5 f0 ?
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用2 F0 \, o) V. O7 f6 w
(1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
3 c! ]4 i1 L9 @* X) [) u& K (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
# ?: W0 Y+ c. V8 w4 c && args(str)”)
; [1 E3 u/ }0 ` @1 T! _+ j! T 2.直接引用匿名的pointcut5 e, y" g2 i4 v0 ]/ i$ _
(1).@Around(“execution(
: ~6 h1 }& j' S* a * com.javakc.spring.schemaaop.Api.test1())”)4 h0 J6 i- e; p" H f8 s# k, f( o: p
(2).@Around(“execution(+ p5 S2 ~+ h1 p( C$ e, A8 @) o7 m
* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
+ J8 |, t- D0 X$ W // @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
6 Q) d1 U1 O+ w4 x* O- X @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
" U$ c( y, N" H1 Q M public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{3 n4 o- O+ e; {' T
System.out.println(“around1==========before1pointcut==>”+str)
" S. p) ]8 q9 m! _# ~5 d( [ Object obj = prj.proceed();
9 ]% }1 p# h8 C8 s. N3 ?3 C System.out.println(“around1==========after1pointcut==>”+str);0 A2 z H8 k- p& [& {
}
U1 s h, u6 r 5.4.3.@Before
! A- T2 T+ u: |. H& Z5 g/ J2 {0 @# ] 注解@Before在执行目标对象的方法前追加相应的功能1 j/ A$ i" ^" d" c
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用6 v0 v$ P. B! l" a# ^
(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
1 d4 v! I0 x7 ~5 b1 _" K2 @7 ?! I (2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
+ N5 d, G- h) y3 M 注意args后的名称与参数名相同, \/ }2 U' F/ B
2.直接引用匿名的pointcut! [5 F7 s' H% M2 _
(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)6 ^ ~3 k" u4 V* K8 o- S( Q
(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”) D% t8 ^- w) G6 Y% g; U4 e/ d
注意args后的名称与参数名相同
: h2 P: q: X: f( ?& Y // @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”), [1 h; o# U* _4 ]; p4 S* D
@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
) t7 Z' Y% N, I, A# |# A public void testBeforeParam(String str){
$ `' H7 L7 V/ _- E: k System.out.println(“before1=param=>”+str);
- N* Q W7 s4 \, f1 S( s }8 \9 c* b0 @0 g% H' v6 F) a, I1 e
% m8 `! p" ?& l q5.4.4.@After
3 } n) ~. B9 F% N! [ 注解@After在执行目标对象的方法后追加相应的功能$ Y1 f k6 d0 j7 k$ r$ A. W' i: a5 E
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
; t3 \1 a$ c$ O, N (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
5 g; u5 y8 S x3 r" [/ E! ]5 ^0 o 2.直接引用匿名的pointcut
+ n% S* P. K8 Z5 s! E6 s& z (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)5 J+ g4 |$ ~/ ?& ?. u
@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
% U1 L/ L! ~! l2 f+ D' I public void testAfter(){
& ^3 }; r6 a7 N System.out.println(“after1== >pointcut”);
( l. o, E: Y/ W }; m7 ]- H& e+ b2 ~! P7 P8 A
5.4.5.@AfterThorwing
+ D9 ^3 ~( ?2 U9 u7 }1 G
5 L: |+ E4 E4 q3 m+ d' m; K1 Y- j& S A V0 y2 o
- 描述一下spring中BeanFactory和ApplicationContext的差别9 O% V; E2 o' c7 T
, J% j1 B. z% v6 W1 K
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”);
: S* m0 g$ D* {9 a {- 谈谈spring对DAO的支持
2 X2 h. U3 ]# R8 O! Q, K: P
. i6 E. j: w' K: j
Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
) k, a6 s8 L$ |: j9 N, o5 L7 m; b0 F 简化 DAO 组件的开发。
0 B- C7 h/ R1 DSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法,用来简化代码开发。
: B; R X. ^3 V* w8 J0 n7 L' S IoC 容器的使用,提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件,都由容器负责注入到业务逻辑组件中,其业务组件无须关心 DAO 组件的实现。
! F9 ~4 J# @ z5 q# `* ~$ j, e 面向接口编程及 DAO 模式的使用,提高了系统组件之间的解耦,降低了系统重构的成本。
+ u) y/ L8 W4 D 方便的事务管理: Spring的声明式事务管理力度是方法级。$ `5 E0 b' x. h; ~8 S2 r
异常包装:Spring能够包装Hibernate异常,把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常,从而避免烦琐的 catch/throw 及异常声明。8 Y" G9 S$ |! {/ r p; y3 J5 K
7 g ^: T' J; x+ d: }) {/ R
7 O: @2 f* s6 x- 谈谈spring对hibernate的支持
6 U3 j9 g( @0 ] c* U0 o1 l2 v" ?7 J# T; X; m( ^1 b e
在所有的 ORM 框架中, Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外, Spring 还提供了统一的异常体系及声明式事务管理等。/ W% i9 y2 f9 r' d! |2 _0 T7 y+ F
一旦 Hibernate 处于 Spring 的管理下, Hibernate 所需要的基础资源,都由 Spring 提供注入。Hibernate 创建 SessionFactory 必需的 DataSource ,执行持久化必需的 Session 及持久层访问必需的事务控制等,这些原本必须通过代码控制的逻辑,都将由Spring 接管ataSource, SessionFactory, TransactionManager等,都将作为 Spring 容器中的 bean。将这些bean 放在配置文件中管理。3 P2 ^& Q5 @8 w3 r( P9 w
1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory,使得配置值很容易被管理和修改,无须使用Hibernate 的配置文件。详细配置如下:
7 @# Z7 H% ~$ c' |4 R$ o. C/ {" W
. w( X. K* v* T0 P( V& F/ @2 a class=“org.apache.commons.dbcp.BasicDataSource”>
h6 B- d' h& |9 E1 } 7 J3 f0 K0 q9 s( b! A; ^+ [
oracle.jdbc.driver.OracleDriver
2 m p$ Y4 ^' m6 ], }5 c
% T& c9 w1 F' y0 s! u9 A: o, t) y% V, I 2 `; A! w, _# K' j! X4 M/ m
jdbcracle:thinlocalhost:1521rcl
/ X% v3 E+ t) `: R+ m9 z1 G; T8 e
7 Y a8 d8 a1 s! x % i' W" p/ N5 J0 D- z
javakc25 c8 s: w% g w" _% b7 M b7 `7 u
& }' N9 V3 Q' ?4 _: \
% c1 j6 {6 q3 v+ P
javakc2% F+ u# Q0 q/ G* ?1 h/ d' Z
6 l6 d9 q7 W# x: q$ n1 }7 h
6 b# j, g- A" N- E ( i3 ^5 ~: U5 C1 N, V
class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>& J! }& @5 o2 }6 {) `/ F2 v; Z, C: }
, E/ P5 `; P" D2 K. G7 V" T1 e
- E5 x$ F9 S9 h$ W6 H* S( a7 `6 h2 N
; N3 ^. I& F6 c: A' t com/javakc/spring/h3/UserModel.hbm.xml
* l+ X% o2 Y& B+ b% m/ J % d+ x& C* u7 ?
) J- c" f3 n( k! n' e8 N9 M1 u . h X9 `- W! I7 @! @
9 Z, Z( V- |; s7 c, O hibernate.dialect=org.hibernate.dialect.OracleDialect& l; |4 N+ m+ v; r6 c! Z5 a
- q/ H) p% I! i( J; Q5 g
* c4 P7 {8 r# K9 U
6 E l. A) S5 |, k6 F8 M. ^5 ~' I
8 w5 ~4 W1 w- W
8 r6 ?- G7 M8 |3 W& A % ^% g% T2 \% G# S
如果需要使用容器管理的数据源,则无须提供数据驱动等信息,只需要提供数据源的JNDI 即可。对上文的SessionFactory只需将dataSource的配置替换成 JNDI 数据源,并将原有的 myDataSource Bean 替换成如下所示: class=“org.springframework.jndi.JndiObjectFactoryBean”>
: A2 k. }$ J& `3 J0 r) \ ( I( l( C6 U3 _1 A! Y Y# C7 U
java:comp/env/jdbc/myds7 ^ k Y& f( A( Y9 ]' n
4 q' r" h1 g- ^( b L8 Q# d 2、有效的 Session 管理: Dao类继承HibernateDaoSurport后,Spring 提供了 HibernateTemplate,用于持久层访问,该模板类无须显示打开 Session及关闭 Session。它只要获得 SessionFactory 的引用,将可以智能打开 Session,并在持久化访问结束后关闭 Session ,程序开发只需完成持久层逻辑,通用的操作则由HibernateTemplate 完成。 3、统一的事务管理。无论是编程式事务,还是声明式事务, Spring 都提供一致的编程模型,无须烦琐的开始事务、显式提交及回滚。 建议使用声明式事务管理,Spring 的声明式事务以 Spring 的 AOP 为基础。可将事务管理逻辑与代码分离。代码中无须实现任何事务逻辑,程序开发者可以更专注于业务逻辑的实现。声明式事务不与任何事务策略藕合,采用声明式事务可以方便地在全局事务和局部事务之间切换。 Spring声明性事务有两种配置方法,一种是xml配置:
4 u$ g. @. [# n( x$ V% T
0 O3 c- K( W9 a; B) e0 B: {7 A# ?
! J: U7 ]0 c, P. I- i) F
# M# ?; d2 m6 Y" x/ } ) ]; N z/ g4 y5 n& w
+ ? y- @3 H7 o6 w + U( R& H+ V; L0 o% k
+ R4 o+ A# B) T; h9 F. Z- A) L3 N3 [1 y
A! k* l* a( Y4 H* f1 l& L6 W 9 d# g# L8 \+ P& j; x8 e
5 {. e: p& q3 R; T5 n 9 Z% `# U. ?% k( N4 N* l
% j* E7 X$ j3 M6 p/ H. l9 O+ _
) `/ P; s+ U/ r4 k
另一种是通过注解,在需要添加事务的类上注明 @Transactional 6 n' ~! S; J; u/ U' ~% r6 {
Spring2.0之前事务的写法# E* l0 ?, x$ d2 e
5 d3 V; ^0 `) u8 J: [( v7 o3 V0 s3 \1 H7 F) j
class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”: X6 [6 t$ j w* g
7 B/ t; o# [$ V+ p7 n8 b6 \ abstract=”true”>/ [8 k* n" u, {; ]2 D) J
: ?. n$ d5 c, }% A
; ]' @4 v& S( D3 D( v5 T
* v. q* i- o+ ?' r4 L; x% ~1 o- e3 C8 H2 t
PROPAGATION_REQUIRED,readOnly
5 [ c# o, ?$ ^& V+ f9 y' E% {$ L6 i
PROPAGATION_REQUIRED
- X: |" C) |+ p, n L6 c$ l* ]5 x" ]- ^2 ?9 C) G! N4 R; x
! K) Y2 n7 c6 k- z- y5 V3 G. e" Q0 `, I) a+ S4 ^/ M# i
6 x4 Q5 ]+ @* X% o+ X
| ' u# d7 S4 w! u B
r* k5 W2 I' T9 E; u5 V _
- 谈谈Spring对事务的支持
' k: t2 \' P0 Y$ Q7 b# }& u6 c* L4 x3 D* V5 U# a
2 s7 q- F9 u0 J s, r( K1、声明式事务管理:
1.流程:由客户端访问—-aop监控—-调用advice来追加事务 2.做法: 2.1 在配置文件的头中引入xmlns:tx 和schema的文件 2.2 2.3 注入数据源
2 B+ @6 q# C, c4 ^3 X8 h% y
& |8 N9 a& v1 t
( r y2 K6 e- C! z- h3 j
' H' G7 {+ y l3 Y6 M/ \, a1 H" ?5 C
; e# `+ c, Z8 I2.4 由spring实现的事务管理,但需要注入数据源 0 y/ [/ \! ~# \
' ^% F6 }0 @& w: w' `
8 I* J$ V. x8 b: b6 k7 X: e+ j7 K2.5 事务监控所有的方法(事务加强) 6 G2 i% x/ k# K4 F8 n5 s: M
5 z5 |6 L E- D- E% a" ~0 B! o: Q! U2 K: Z! D' H
' I! Y8 x8 J* a( c9 [
9 C% i; E5 E/ p3 ` A1 t" U
2.6 定义切入点 , C% n1 _$ g( S. t
6 r' S6 @* @* E- K5 p$ ]" l! l* p; o* ]5 c. s6 s9 l2 W
5 R1 r& [1 p6 P" P h
1 f4 T- t3 z7 ?) ?( T. j) w
2、使用注解实现事务管理: 1.注解@Transcational (可以在类上,也可以在方法上) 2.在配置文件中同样需要注入dataSource和spring的事务管理 3.使用注解的方法来追加事务 注解驱动 ) }) V' J8 z6 z8 T, w+ P3 r
/ C. V! ~ [7 Q. r$ K+ x [1 |) K8 h
如何在Spring中使用Hibernate的事务:- O! y; \% Z+ f# ~4 l+ }+ y
* V4 n8 ?/ T) N6 w* K
3 @- @3 q0 e/ A5 P6 Q
8 i( z8 {6 ?; r/ @7 F5 ~1 @如何在Spring中使用JTA的事务:
7 G; y4 @2 D0 i3 n6 y
- D5 W3 S0 y; x2 c" Q |