Spring
# |/ S% _9 d' }7 @1 ]% L- 是什么?% {2 Q( ?$ x; I/ X/ _# t
: W* I Y* R, y- @! w
Spring是基于JEE的轻量级的应用框架 ( |. o' L( I1 w. N" u, d ]$ V0 W
- 有什么? @" |# m. p4 V, U' y/ Y
0 x5 }+ S4 M+ y2 b1 A2 T' h8 U! R % L0 f- k9 s& x& y: }
每个包的功能: Spring MVC:spring 本身提供的web 框架 WEB:集成其他的web 应用的框架,或者说是对其他web应用框架的支持。如struts,webwork JEE :集成一系列的jee的技术(对JEE技术的支持) DAO:封装了JDBC;(对JDBC的支持) ORM:提供了对ORM工具的集成(支持) AOP :面向切面编成 CORE:spring的核心包,提供bean的工厂和IOC容器 : a4 h8 R' S+ {+ v" [ E0 m/ H
- 能干什么?
& Q( f( Z& @/ r; b2 o- j7 a& P( G; Q& }
把一系列的jee的技术有效的组合在一起形成以良好的系统
! i. Z" a# E. u) ^3 ^- 怎么用?
) B' o6 B8 u" u$ D: k3 t7 c
& o$ b, `1 }& y! y- ^- 搭建web工程,引入spring的jar包7 V' E# a8 u1 Q% K
- 在web.xml中添加如下配置
J$ H/ {: n# Y6 M' {4 v4 w6 ?" K7 H3 N
, U6 x# W/ t$ j! R
- F6 h& Y V: O: K9 v6 `; X- F) d6 O
contextConfigLocation9 d: G; b9 r& P7 n% t. E9 Q! w' a+ m1 J! ~
classpath*:applicationContext*.xml6 N; }4 j# A0 ]+ s/ V. W$ V
# T3 B6 c, _9 a# `
* I: L& t5 x0 b9 Q struts2
2 y3 s5 t7 m, Y% m! Z 3 W$ U/ [$ d) J7 |4 }" ~
org.apache.struts2.dispatcher.FilterDispatcher' F2 ^' D9 u* o
! k: c5 ?) V% S. D* R
, a8 _5 p) ^8 E! k8 h* i 7 d/ q4 B8 C/ ]
struts22 Q0 g$ x4 z& ^9 ]6 y( z
/*
8 B( g! `& e1 \- C2 \3 _
1 J: [- z- a0 G: e+ N/ `. ~
% n; y9 g/ Z5 }2 c# T" d e
+ f5 e7 |/ \4 ~
org.springframework.web.context.ContextLoaderListener
0 w- M1 Z# z4 T4 W+ t. ]3 y& x + ^4 W7 A* _! L- v* v
- 部署) r. p0 n) Y0 G! o$ o
, y. ~* K+ V9 I1 B0 K6 \+ p 9 h* p- v% D, x( r/ u0 b6 P7 m) e
- t* b" p5 z5 K" y8 M
0 D4 S2 P) i [9 b; u0 N4 y- 容器和bean
- ? U H+ N, ?$ u; }/ D9 M
Bean :是指受spring的ioc管理的对象称为bean 容器 :(与jee的容器类比) Jee :提供组件的运行环境和管理组件的生命周期(不能单独存在) Spring :提供bean的运行环境和管理bean的生命周期(可以单独存在) ' K; |* i/ e" l
" X7 B) ^( Z; M; p- n
- DI依赖注入/ j: J+ j6 ~6 V) \( A4 U
1. 应用程序依赖spring注入所需要的对象 IOC和DI是对同一种事情的不同描述 2.setter注入: 在配置文件中将接口的实现配置为bean在应用程序中注入bean 例如: 在配置文件中 2 S# O! y9 T+ f; x7 x
' j5 l+ D/ o, v, d7 H# _" ^
" y$ \2 Y# Q6 Y5 [& J* g
在应用程序中 Public DBDAO dao ; Public void setDao(DBDAO dao){ This.dao = dao; } 3.构造器注入
9 }) W, E- s Q4 h4.ref 表示参照其它的bean 在参照的过程中一定要注意死循环 5.自动装配———–〉no 自动装配根据名字来匹配相应的bean 尽量不要去自动装配 6.lookup注入 7.singleton 1.单例模式是整个的jvm中只有一个实例 2.spring的singleton是指在spring的容器中只有一个实例 一个生命周期中只有一个实例 8.DI的优点: 1.程序被动等待,强化面向接口编成 2.切断了对象或组件之间的联系,使程序的结构更加松散,运行和维护更加简单
4 W; S. y( R3 S0 l, e/ M- Aop面向切面编程* f" Q& I$ {7 X' A
0 u7 N. `; ^' @& o
1.AOP面向切面编程 一些较好的模式或者是示例—-范式5 {) m7 n/ ~- D1 N
切面:一个切面代表我们所关注的一系列的共同的功能点(模块之间的共同的功能点) 2.AOP的思想: 主动—->被动(追加功能)2 q3 }* J7 p7 [1 ^) g1 }
3.AOP 的概念9 @9 Z3 i4 T+ w; W- K& T
1.切面 :我们所关注的功能点 2.连接点 :事件的触发点(方法的执行) 3.通知 :连接点触发时执行的动作(方法) 4.切入点 :一系列的连接点的集合 (连接点的模块化) 5.引入 :扩展的功能 6.目标对象 :包含连接点的对象 7.aop代理 :实现机制 8.织入 :把advice和目标对象连接起来 4.AOP的事件机制0 ?8 F* v0 m2 C* ]
1.通过切面找出一系列共同的功能点 2.找到目标对象(在标准的spring 中 接口的实现类为target) 3.找到切入点 4.确定连接点 5.通知spring AOP,查询xml文件,通过代理找到advice。 6.由aop代理来实现动态织入
/ R1 |# a" w7 ~! |3 U
1 W$ t7 |6 O! Y
$ h* a1 I/ h5 X) B4 Z! `7 _9 B p) U: b- b* q K
7 y( I( Q# l0 L! o! f# x3 ~
1 `& h) e( l; N4 g3 X0 G3 s0 {7 [1 ~# C/ g+ ^ C
5. AspectJ0 P f0 i v3 X* \
5.1.在xml中配置比较烦琐
: b& j0 B% @! f3 F6 j' i0 O9 M) h 所有的入口必须从一个代理(ProxyFactoryBean)开始
( }6 i" J9 m" e2 I
% V; c7 G" `* ?$ C. N7 M $ l6 I3 l4 p T4 S; m
0 l7 |/ F+ ]/ ?( k6 v) U
; L1 m7 L) Q4 u) l* R) m1 v& P7 _
& H( [+ |7 Z1 |# {1 x2 a2 o% {
) ^4 w7 _, |& S: i' w
- `1 O% e! z& M9 Z9 c. K) N* q
+ D$ _: V5 V; E) \" k) X3 jexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>% G$ J) y) E/ @5 u; V+ Y' i
# p) i* b8 o. G: v& L+ h
6 r, B+ p( T6 E4 A5 l t0 a
7 L5 A$ j6 a- [1 v, U4 m1 D $ {3 c# v8 L% d9 T* [" m
?% J: l* m3 N8 I
5.3.使用注解的方法相对简单& g. N' v$ o. V4 [" y$ }3 F; [
@AspectJ的基本语法
0 [/ X c A' F6 V6 y' u) B 1.@Aspect声明一个切面,将一系列的共同的功能定义成一个切面
4 \: q6 a/ p7 ~# y 直接在类上定义@Aspect/ r) O8 [5 C, W% ]6 M
2.@Pointcut声明切入点
" a# Y9 e- g" Y$ Z& C/ w3 N: V 2.1、用一个专门的类来定义pointcut,类中的方法名就是该pointcut的名字- ]6 U3 u9 @; M' D7 h
2.2、可以使用匿名的pointcut
* E& Q4 P8 ^/ z8 }4 f5 F5 g6 w 2.3、执行切点的几种方法
' g- X. G; b/ Q' r! }0 Y- t+ m% O& ^ 2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法5 a4 v3 P) q0 W* L- l
2.3.2 within 指定到包,不能指定到类
. L! l& M% Z! H3 ^$ v | within(”com.javakc.spring..*”)
' l; K. m, x% s% S( v" c4 ^6 ^ 2.3.3 this 指定到实现接口的所有的实现类' Z; E# S# c9 ?0 ]
2.3.4 target 指定具体的实现类
+ N' X8 v. p( P. V* a8 {7 F 5.4.advice的五种类型的示例
" D2 U# f3 U0 G! D4 X3 S! o 客户端必须从接口走才能得到监控,实现想要追加的功能
( U9 S- P4 {- x: b4 Y; ]1 N; F. z 5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
' f/ w6 _# {- _7 y& t 追加的方法的参数名字一定要与retrning的名字相同! ?; E4 `+ g9 k* }( x
在注解@AfterReturning中必须加上pointcut和returning两个参数
( Y: G2 k) o' N! l/ \0 A. E" e pointcut指所要监控的目标对象的方法
- l; f6 P* x# j7 _" ?, q 得到目标对象的方法的返回值,来作为参数,进行下一步的处理,参数没有顺序,按参数的名字进行匹配
# z# j+ |, j( U: c 完成追加的功能
0 i( q8 a1 T+ N5 x' N* s2 w; Q* p; D 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
0 c* t0 M8 D3 `% R2 o6 V8 Q (1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
2 b5 \9 \. a. @ E! \- x1 j% Q2 m& b (2).
8 u, u2 o- v$ p1 w+ S3 f$ z6 J4 r 2.直接引用匿名的pointcut# u- L1 x% u3 Z9 l
(1).@AfterReturning(“execution(
% T$ q, B2 o7 j0 l4 Q' Y9 G% k * com.javakc.spring.schemaaop.Api.test4())”)- E8 K9 M4 Y5 W4 g! f8 p7 C
(2).@AfterReturning(pointcut=; }6 W3 z! g$ y" s7 t1 c3 k; R
“com.javakc.spring.schemaaop.TestPointcut.t4() &&
7 k7 K; G3 ~6 A9 g1 J4 R args(str)”, returning=”retVal”)& |. D: Y+ L' S c1 {
@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)* }4 [( F% M* C' R2 f4 A
public void testAfterReturning(String str,Object retVal){
) M1 k9 Q2 Z, P8 r System.out.println(“afterReturning1=>”+retVal+”=>”+str);
3 ~8 N& u+ Q2 e# |* y4 s9 B }5 h2 r# \- K; ]0 m: S7 U' s
5.4.2.@Aronud5 T1 m6 f% p5 ~7 X b
注解@Around环绕追加功能;* Q7 s9 i" v4 w G' `
在执行目标对象的方法的前、后追加功能;
( B/ i0 r8 M, K G 必须有参数;第一个参数的类型必须为ProceedingJoinPoint;: q' h9 r% b( S$ O- Y
通过ProceedingJoinPoint的实例的proceed来调用所监控的8 G6 r' L. g$ P/ H* q# h
目标对象的方法( o9 l6 t3 `. Y7 ]
1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
7 S! q. M- X5 l* H4 f (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
+ G) I h$ L: v3 I, a A3 u (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()& ^( m% V7 k s" a# K. j
&& args(str)”)
7 M" a8 a) d' L" w. | 2.直接引用匿名的pointcut* p3 v' c- n, x8 o
(1).@Around(“execution(
& ]' V' K- j; K+ s% T4 Y * com.javakc.spring.schemaaop.Api.test1())”)7 s: h0 i# i I1 B: w0 ?) `, Z0 r; ^
(2).@Around(“execution(- ^- N% y; t4 J! }% c6 @1 Z
* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)9 K+ L- ~) Q# w( o$ P
// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
4 F& Z, e8 r% n" [8 O, ~9 w3 i @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
: q- a( w7 n0 a Y5 D. W public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{- Z4 ^+ Z. P: }; g) D% ~' H' [
System.out.println(“around1==========before1pointcut==>”+str)" G) i% ]2 g/ F( _
Object obj = prj.proceed();- h$ n+ {$ d! u' R" ~
System.out.println(“around1==========after1pointcut==>”+str);
9 W" b1 @7 Y+ ^0 I7 D# t }- I# A: ~) v. W% ?) S$ w1 v
5.4.3.@Before- @0 k) T- K; t: o4 a! T
注解@Before在执行目标对象的方法前追加相应的功能
0 J: A6 y3 i( A5 T 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
, `1 j6 D. d4 o7 t, P" I; [+ v (1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)+ G! y7 r& u+ s
(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”). T+ b0 f y; b- u2 r
注意args后的名称与参数名相同
! y% B* @9 W+ H) x1 H. Z 2.直接引用匿名的pointcut
& L: [8 H, X) v2 O" t8 w- u/ f6 t (1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
. C2 q+ l' I& Z7 z4 u, N9 o8 [ (2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
7 E( C9 F4 `% \* G Y 注意args后的名称与参数名相同
' Z) P& ~% j9 {; q // @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
i0 V' B O, h' X+ S# Z; F% p- z @Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”). B! z4 ]7 u; n: a; L/ W
public void testBeforeParam(String str){
' r1 I) q6 v) k4 n System.out.println(“before1=param=>”+str);" v" r4 Z" X$ h) P- q7 S; t7 H
}
! P: N N( ^6 q* J" ? ! R m1 x( b; b! l
5.4.4.@After
! p& Q' S4 b G4 s% }- T0 D N 注解@After在执行目标对象的方法后追加相应的功能
6 k! l/ b5 W' Y, { 1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
0 o. Z: h7 @, Z x+ U$ P (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
- `: d8 w, F* w( r9 x 2.直接引用匿名的pointcut6 e' \) d' L4 C3 R' S# @
(1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)& Q+ B; o" F" W) Y7 N d' |. g% X
@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)% U0 B: C4 _* t1 l$ r
public void testAfter(){0 r5 g6 {8 q$ w2 U4 {6 L6 u
System.out.println(“after1== >pointcut”);
0 U( L. \' i! z7 @. [ I }2 g7 ^. ]; l# m3 i/ ^, l& c" P. o
5.4.5.@AfterThorwing$ C' p8 x; X9 X* f& b' |
( [$ E$ \3 ~% S8 G
) b) v4 q" z L3 ?, ?
- 描述一下spring中BeanFactory和ApplicationContext的差别0 N( i" M$ n* G8 F3 v% `. f
$ L- j! Y) @, @3 U5 Q
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”);
+ u# o, S. n& M) o" `- 谈谈spring对DAO的支持0 ]8 m2 {' \1 a1 s
' f C4 n* h4 b
Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。" i# J7 E# N+ j% q5 q9 ^/ N
简化 DAO 组件的开发。
; i7 C- @$ g ^Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法,用来简化代码开发。* j/ X7 R$ N6 A; s W1 A2 t. E
IoC 容器的使用,提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件,都由容器负责注入到业务逻辑组件中,其业务组件无须关心 DAO 组件的实现。 j! K6 i( A. i% ?2 s! [2 [6 z
面向接口编程及 DAO 模式的使用,提高了系统组件之间的解耦,降低了系统重构的成本。
( A" I7 g. u7 ] 方便的事务管理: Spring的声明式事务管理力度是方法级。
+ n8 W# O: E8 p2 Q 异常包装:Spring能够包装Hibernate异常,把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常,从而避免烦琐的 catch/throw 及异常声明。2 o* l! v6 o" x) c, K
+ U. w- ^9 m# F( f4 C0 b4 ]$ N5 r. j2 ~) d
- 谈谈spring对hibernate的支持. i& _4 s5 q4 U5 N5 e! d
! V+ M0 ~! Z# m
在所有的 ORM 框架中, Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外, Spring 还提供了统一的异常体系及声明式事务管理等。0 U2 m2 T- ?8 V8 g$ Z( U
一旦 Hibernate 处于 Spring 的管理下, Hibernate 所需要的基础资源,都由 Spring 提供注入。Hibernate 创建 SessionFactory 必需的 DataSource ,执行持久化必需的 Session 及持久层访问必需的事务控制等,这些原本必须通过代码控制的逻辑,都将由Spring 接管 ataSource, SessionFactory, TransactionManager等,都将作为 Spring 容器中的 bean。将这些bean 放在配置文件中管理。* X5 @* D) E) A8 q
1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory,使得配置值很容易被管理和修改,无须使用Hibernate 的配置文件。详细配置如下:( h2 i4 n; W$ J! Z4 p
4 [: ]9 Z- Q7 m4 _ class=“org.apache.commons.dbcp.BasicDataSource”>
; F& Y3 e$ d7 f% Y6 k1 F: q4 w 3 U: C) S$ Z+ j, l$ F
oracle.jdbc.driver.OracleDriver! C5 J H3 \" a( S& t# Z! u
9 V, ^& c& T8 D% r% J+ ^2 x
& ]* ^9 Z. `7 N/ @
jdbc racle:thin localhost:1521 rcl/ {% @ q; Y8 J* L; m! W' p
8 h9 O+ V) G9 Y8 O! ^
, x6 u0 ^, y! f- j/ F# Z
javakc2
) D" h1 G7 C- @$ k7 Q* @ r& \1 N% P( Z
5 u. G, X/ a4 M2 _6 j
javakc2. Q7 ^% x6 d2 O9 I4 Z% h* t }9 ^
' M5 t/ a$ R+ i" B6 O
$ k( r4 O) G! R. | & p+ w8 D9 Y7 U9 w% n
class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>' T; Y# ]4 j( _( g6 s
# `( `' Z) h ~% N7 \6 B* \: p
" B z$ L$ f" w0 m. d6 p 5 L6 o( _( U, ?! b1 c' f+ D
com/javakc/spring/h3/UserModel.hbm.xml) r6 y$ H+ q9 J# d
6 T' f4 M6 U7 i4 Q. Q1 e7 J 3 T/ ` v) u2 E' r9 y+ l
- V" v: o6 n* s4 X
8 U% o' Q" W3 k' r7 @! n" Y0 n5 } hibernate.dialect=org.hibernate.dialect.OracleDialect- @- U4 T! F) a. r/ E. U8 N
4 v0 p9 B7 @3 @4 ~
9 `5 H+ v7 S: E# t
9 e, Y* k# l7 D' n
8 m. J" N) e7 J
; f+ }" d5 M# P6 B$ W# m
! k. s) F+ T2 ]* t
如果需要使用容器管理的数据源,则无须提供数据驱动等信息,只需要提供数据源的JNDI 即可。对上文的SessionFactory只需将dataSource的配置替换成 JNDI 数据源,并将原有的 myDataSource Bean 替换成如下所示: class=“org.springframework.jndi.JndiObjectFactoryBean”>1 w& W6 H: x* F
. c' A% l, j+ B java:comp/env/jdbc/myds# L+ N3 h/ G7 r7 V% i% J+ r( V8 T
) N. p8 A- e3 \9 |7 v5 t 2、有效的 Session 管理: Dao类继承HibernateDaoSurport后,Spring 提供了 HibernateTemplate,用于持久层访问,该模板类无须显示打开 Session及关闭 Session。它只要获得 SessionFactory 的引用,将可以智能打开 Session,并在持久化访问结束后关闭 Session ,程序开发只需完成持久层逻辑,通用的操作则由HibernateTemplate 完成。 3、统一的事务管理。无论是编程式事务,还是声明式事务, Spring 都提供一致的编程模型,无须烦琐的开始事务、显式提交及回滚。 建议使用声明式事务管理,Spring 的声明式事务以 Spring 的 AOP 为基础。可将事务管理逻辑与代码分离。代码中无须实现任何事务逻辑,程序开发者可以更专注于业务逻辑的实现。声明式事务不与任何事务策略藕合,采用声明式事务可以方便地在全局事务和局部事务之间切换。 Spring声明性事务有两种配置方法,一种是xml配置: 7 _ p( E) o5 U; B6 ^0 _* R& C
: m0 Q; j: e! d6 ~ @1 ^) P- t
0 t* b ~2 z; g 2 @) f6 H4 P" o1 K4 A
) z6 v% K# U& s8 T
2 i3 }" ~# z+ F0 v6 m: a: V
; r4 m' ]- b3 t7 @3 K
% t2 }# R& q( l* s
& I5 e# ], u$ S" W
% g) Q- P4 m9 Q- d: D
/ S6 t' _4 D% D; W
- u) z7 l4 X/ l3 |, {+ g" B
, ?; ]' e' T; G& [9 S% z- r. o! R
) i# o4 ]2 \ T1 c2 t% o/ x 另一种是通过注解,在需要添加事务的类上注明 @Transactional
; _; v: F0 P0 C1 k5 K1 m/ v! YSpring2.0之前事务的写法9 q# X0 q5 Q& T( g8 j
% m! h7 Y, T$ u. }. q* G# L
% Z$ O u8 ?6 Z; V4 u2 Q0 R# |- B+ y class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”- ]+ E8 j% N9 e8 [* N: ~ H
* g* w; I- ?; n
abstract=”true”>1 n& l9 l3 O( C8 V9 _
* N7 ?9 D8 _7 E% I
. b2 C: [ L0 ]8 H# s5 l
4 s2 E6 o0 Q& D7 X7 o
& N- m- g% N: u( f& a6 H PROPAGATION_REQUIRED,readOnly) V& c8 ?2 Y" d6 A) U1 ]
1 z/ o% \/ a( t+ E
PROPAGATION_REQUIRED. x& X) {- ?5 H" X
8 u: o6 D" P) a6 I' G+ ~: K
# h' m% Y+ f5 M$ ~$ ` ]1 V
, V* _' z) O* f! Z |; }3 ] A
. f' k% }1 _8 {* e7 ^* W% Q |
" i# d5 k3 }; Y+ n& T; u2 Y5 s( y1 M% \# r$ B) {5 K5 y
- 谈谈Spring对事务的支持
# \0 D) z* J. X" A% g4 n+ L- i+ x8 D% { u3 n7 T( }) G
0 p# c |) e6 V8 E1 j. u1、声明式事务管理:
1.流程:由客户端访问—-aop监控—-调用advice来追加事务 2.做法: 2.1 在配置文件的头中引入xmlns:tx 和schema的文件 2.2 2.3 注入数据源 - Q4 z& N2 M) [+ i
. N9 H! e# k- G6 f- a; f9 y5 h, k' l
9 b( m: \% h! ?$ d A# T
. y; Z$ l5 \4 r1 s1 ^ r" F$ J
2.4 由spring实现的事务管理,但需要注入数据源 : c9 i7 {7 @* L; \- k4 X- z5 L
* b0 H* |9 f; C" y; `* t$ `
( u1 I9 J4 M, k* R) \; D: }- q( v2.5 事务监控所有的方法(事务加强) 3 h% W1 R) Q, R3 g: w9 u. p
; u V8 p& b) L. H! V' L- j- k& A
$ n' S- {; a; H b; R G) B8 T: r
+ R N7 ?( v+ J' W0 V( N$ |
$ j# J1 G& z, S2.6 定义切入点 ( c) w. e/ }3 A) E
1 M' k D' U% g# n$ y1 K( J) g
; d8 h K. o( s8 _, x; X F4 l; {, Y% Q
& `7 r1 @/ Y5 K2 A+ f) K* l
! b* p# d- M9 I9 g& |5 m2、使用注解实现事务管理: 1.注解@Transcational (可以在类上,也可以在方法上) 2.在配置文件中同样需要注入dataSource和spring的事务管理 3.使用注解的方法来追加事务 注解驱动
7 w/ @- |" ?- h* ]+ |. p4 y7 G5 x/ Z- ^. R! p- c6 c$ w3 W& o n
如何在Spring中使用Hibernate的事务:7 }2 @3 ~/ _% Y5 h
1 ^- z2 \6 a( R4 Q1 V9 @
. O7 i2 I& G2 a. [$ n9 O$ f! w
4 X) ^ t+ K. l% j: @0 S如何在Spring中使用JTA的事务:
; R% @% h1 b Y) l
% v" [/ x2 a* w* F |