spring 入门教程详情

最新推荐文章于 2024-08-01 22:00:59 发布
最新推荐文章于 2024-08-01 22:00:59 发布
阅读量272 收藏
点赞数
文章标签： spring java nested jdbc 企业应用 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/majinlongjinlong/article/details/5682137
版权

您还未登录 ! 我的应用 登录 注册 .
.论坛首页 → Java编程和Java企业应用版 → Spring → 详解spring事务属性.全部 Hibernate Spring Struts iBATIS 企业应用 设计模式 DAO 领域模型 OO Tomcat SOA JBoss Swing Java综合 myApps快速开发平台，配置即开发、所见即所得，节约85%工作量 ? 上一页 1 2 3 4 5 下一页 ?浏览 44662 次锁定老贴子 主题：详解spring事务属性该帖已经被评为良好帖
作者 正文
klyuan
等级:

文章: 201
积分: 502
来自: 深圳

    发表时间：2007-05-10   < > 猎头职位: 上海: 30万起年薪诚聘平台高级架构师 相关文章:  
■spring事务详解
■Spring 声明式事物管理详解
■解惑 spring 嵌套事务

推荐圈子: struts2
更多相关推荐 Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理大量的try…catch…finally代码。
我们在使用Spring声明式事务时，有一个非常重要的概念就是事务属性。事务属性通常由事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划分时，需要进行事务定义，也就是配置事务的属性。
Spring在TransactionDefinition接口中定义这些属性,以供PlatfromTransactionManager使用, PlatfromTransactionManager是spring事务管理的核心接口。

Java代码
1.TransactionDefinition  
2.public interface TransactionDefinition {  
3.    int getPropagationBehavior();  
4.    int getIsolationLevel();  
5.    int getTimeout();  
6.    boolean isReadOnly();  
7.} 
TransactionDefinition
public interface TransactionDefinition {
    int getPropagationBehavior();
    int getIsolationLevel();
    int getTimeout();
    boolean isReadOnly();
}

getTimeout()方法，它返回事务必须在多少秒内完成。
isReadOnly(),事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的。
getIsolationLevel()方法返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。

在TransactionDefinition接口中定义了五个不同的事务隔离级别
ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应
ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。
  例如:
  Mary的原工资为1000,财务人员将Mary的工资改为了8000，但未提交事务

Java代码
1.Connection con1 = getConnection();  
2.con.setAutoCommit(false);  
3.update employee set salary = 8000 where empId ="Mary"; 
  Connection con1 = getConnection();
  con.setAutoCommit(false);
  update employee set salary = 8000 where empId ="Mary";
与此同时，Mary正在读取自己的工资

Java代码
1.Connection con2 = getConnection();  
2.select  salary from employee where empId ="Mary";  
3.con2.commit(); 
Connection con2 = getConnection();
select  salary from employee where empId ="Mary";
con2.commit();

Mary发现自己的工资变为了8000，欢天喜地！
而财务发现操作有误，而回滚了事务,Mary的工资又变为了1000

Java代码
1.//con1  
2.  con1.rollback(); 
//con1
  con1.rollback();
像这样,Mary记取的工资数8000是一个脏数据。

ISOLATION_READ_COMMITTED  保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。

ISOLATION_REPEATABLE_READ  这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。

在事务1中，Mary 读取了自己的工资为1000,操作并没有完成

Java代码
1.con1 = getConnection();  
2.select salary from employee empId ="Mary"; 
con1 = getConnection();
select salary from employee empId ="Mary";

在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.

Java代码
1.con2 = getConnection();  
2.update employee set salary = 2000;  
3.con2.commit(); 
con2 = getConnection();
update employee set salary = 2000;
con2.commit();

在事务1中，Mary 再次读取自己的工资时，工资变为了2000

Java代码
1.//con1  
2.select salary from employee empId ="Mary"; 
//con1
select salary from employee empId ="Mary";

在一个事务中前后两次读取的结果并不致，导致了不可重复读。
使用ISOLATION_REPEATABLE_READ可以避免这种情况发生。

ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。

目前工资为1000的员工有10人。
事务1,读取所有工资为1000的员工。

Java代码
1.con1 = getConnection();  
2.Select * from employee where salary =1000; 
con1 = getConnection();
Select * from employee where salary =1000;共读取10条记录

这时另一个事务向employee表插入了一条员工记录，工资也为1000

Java代码
1.con2 = getConnection();  
2.Insert into employee(empId,salary) values("Lili",1000);  
3.con2.commit(); 
con2 = getConnection();
Insert into employee(empId,salary) values("Lili",1000);
con2.commit();

事务1再次读取所有工资为1000的员工

Java代码
1.//con1  
2.select * from employee where salary =1000; 
//con1
select * from employee where salary =1000;

共读取到了11条记录，这就产生了幻像读。
ISOLATION_SERIALIZABLE能避免这样的情况发生。但是这样也耗费了最大的资源。

getPropagationBehavior()返回事务的传播行为，由是否有一个活动的事务来决定一个事务调用。

在TransactionDefinition接口中定义了七个事务传播行为。

PROPAGATION_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。


Java代码
1.//事务属性 PROPAGATION_REQUIRED  
2.methodA{  
3.……  
4.methodB();  
5.……  
6.}  
7. 
8.//事务属性 PROPAGATION_REQUIRED  
9.methodB{  
10.   ……  
11.} 
//事务属性 PROPAGATION_REQUIRED
methodA{
……
methodB();
……
}

//事务属性 PROPAGATION_REQUIRED
methodB{
   ……
}
使用spring声明式事务，spring使用AOP来支持声明式事务，会根据事务属性，自动在方法调用之前决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。

单独调用methodB方法

Java代码
1.main{  
2.  metodB();  
3.} 
main{
  metodB();
}
相当于

Java代码
1.Main{  
2.Connection con=null;  
3. 
4.   rry{  
5.      con = getConnection();  
6.      con.setAutoCommit(false);  
7.//方法调用  
8.methodB();  
9.//提交事务  
10.con.commit();  
11.}  
12.Catch(RuntimeException ex){  
13.  //回滚事务  
14.  con.rollback();    
15.}  
16.finally{  
17.  //释放资源  
18.  closeCon();  
19.}  
20.} 
Main{
Connection con=null;

   rry{
      con = getConnection();
      con.setAutoCommit(false);
//方法调用
methodB();
//提交事务
con.commit();
}
Catch(RuntimeException ex){
  //回滚事务
  con.rollback(); 
}
finally{
  //释放资源
  closeCon();
}
}
Spring保证在methodB方法中所有的调用都获得到一个相同的连接。在调用methodB时，没有一个存在的事务，所以获得一个新的连接，开启了一个新的事务。

单独调用MethodA时，在MethodA内又会调用MethodB.

执行效果相当于

Java代码
1.main{  
2.   Connection con = null;  
3.   try{  
4.      con = getConnection();  
5.      methodA();  
6.      con.commit();  
7.}  
8.cathc(RuntimeException ex){  
9. con.rollback();  
10.}  
11.finally{  
12.  closeCon();  
13.}   
14.} 
main{
   Connection con = null;
   try{
      con = getConnection();
      methodA();
      con.commit();
}
cathc(RuntimeException ex){
 con.rollback();
}
finally{
  closeCon();
}
}
调用MethodA时，环境中没有事务，所以开启一个新的事务.
当在MethodA中调用MethodB时，环境中已经有了一个事务，所以methodB就加入当前事务。

PROPAGATION_SUPPORTS 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。


Java代码
1.//事务属性 PROPAGATION_REQUIRED   
2.methodA(){  
3.  methodB();  
4.}  
5. 
6.//事务属性 PROPAGATION_SUPPORTS   
7.methodB(){  
8.  ……  
9.} 
//事务属性 PROPAGATION_REQUIRED
methodA(){
  methodB();
}

//事务属性 PROPAGATION_SUPPORTS
methodB(){
  ……
}
单纯的调用methodB时，methodB方法是非事务的执行的。
当调用methdA时,methodB则加入了methodA的事务中,事务地执行。

PROPAGATION_MANDATORY 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。


Java代码
1.//事务属性 PROPAGATION_REQUIRED   
2.methodA(){  
3.  methodB();  
4.}  
5. 
6.//事务属性 PROPAGATION_MANDATORY   
7.methodB(){  
8.  ……  
9.} 
//事务属性 PROPAGATION_REQUIRED
methodA(){
  methodB();
}

//事务属性 PROPAGATION_MANDATORY
methodB(){
  ……
}
当单独调用methodB时，因为当前没有一个活动的事务，则会抛出异常
throw new IllegalTransactionStateException("Transaction propagation 'mandatory' but no existing transaction found");

当调用methodA时，methodB则加入到methodA的事务中，事务地执行。

PROPAGATION_REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。


Java代码
1.//事务属性 PROPAGATION_REQUIRED   
2.methodA(){  
3.  doSomeThingA();  
4.methodB();  
5.doSomeThingB();  
6.}  
7. 
8.//事务属性 PROPAGATION_REQUIRES_NEW   
9.methodB(){  
10.  ……  
11.} 
//事务属性 PROPAGATION_REQUIRED
methodA(){
  doSomeThingA();
methodB();
doSomeThingB();
}

//事务属性 PROPAGATION_REQUIRES_NEW
methodB(){
  ……
}
当单独调用methodB时，相当于把methodb声明为REQUIRED。开启一个新的事务，事务地执行。

当调用methodA时

Java代码
1.main(){  
2.  methodA();  
3.} 
main(){
  methodA();
}情况有些大不一样.相当于下面的效果。

Java代码
1.main(){  
2. TransactionManager tm = null;  
3.try{  
4.  //获得一个JTA事务管理器  
5.   tm = getTransactionManager();  
6.   tm.begin();//开启一个新的事务  
7.   Transaction ts1 = tm.getTransaction();  
8.   doSomeThing();  
9.   tm.suspend();//挂起当前事务  
10.   try{  
11.     tm.begin();//重新开启第二个事务  
12.     Transaction ts2 = tm.getTransaction();  
13.     methodB();  
14.     ts2.commit();//提交第二个事务  
15.       
16.   }  
17.  Catch(RunTimeException ex){  
18.     ts2.rollback();//回滚第二个事务  
19.  }  
20.  finally{  
21.    //释放资源  
22.  }  
23.   //methodB执行完后，复恢第一个事务  
24.   tm.resume(ts1);  
25.doSomeThingB();  
26.   ts1.commit();//提交第一个事务  
27.}  
28.catch(RunTimeException ex){  
29.  ts1.rollback();//回滚第一个事务  
30.}  
31.finally{  
32.  //释放资源  
33.}  
34.} 
main(){
 TransactionManager tm = null;
try{
  //获得一个JTA事务管理器
   tm = getTransactionManager();
   tm.begin();//开启一个新的事务
   Transaction ts1 = tm.getTransaction();
   doSomeThing();
   tm.suspend();//挂起当前事务
   try{
     tm.begin();//重新开启第二个事务
     Transaction ts2 = tm.getTransaction();
     methodB();
     ts2.commit();//提交第二个事务
    
   }
  Catch(RunTimeException ex){
     ts2.rollback();//回滚第二个事务
  }
  finally{
    //释放资源
  }
   //methodB执行完后，复恢第一个事务
   tm.resume(ts1);
doSomeThingB();
   ts1.commit();//提交第一个事务
}
catch(RunTimeException ex){
  ts1.rollback();//回滚第一个事务
}
finally{
  //释放资源
}
}
在这里，我把ts1称为外层事务，ts2称为内层事务。从上面的代码可以看出，ts2与ts1是两个独立的事务，互不相干。Ts2是否成功并不依赖于ts1。如果methodA方法在调用methodB方法后的doSomeThingB方法失败了，而methodB方法所做的结果依然被提交。而除了methodB之外的其它代码导致的结果却被回滚了。
使用PROPAGATION_REQUIRES_NEW,需要使用JtaTransactionManager作为事务管理器。

PROPAGATION_NOT_SUPPORTED  总是非事务地执行，并挂起任何存在的事务。


Java代码
1.//事务属性 PROPAGATION_REQUIRED   
2.methodA(){  
3.  doSomeThingA();  
4.methodB();  
5.doSomeThingB();  
6.}  
7. 
8.//事务属性 PROPAGATION_NOT_SUPPORTED   
9.methodB(){  
10.  ……  
11.} 
//事务属性 PROPAGATION_REQUIRED
methodA(){
  doSomeThingA();
methodB();
doSomeThingB();
}

//事务属性 PROPAGATION_NOT_SUPPORTED
methodB(){
  ……
}
当单独调用methodB时，不启用任何事务机制，非事务地执行。
当调用methodA时，相当于下面的效果


Java代码
1.main(){  
2. TransactionManager tm = null;  
3.try{  
4.  //获得一个JTA事务管理器  
5.   tm = getTransactionManager();  
6.   tm.begin();//开启一个新的事务  
7.   Transaction ts1 = tm.getTransaction();  
8.   doSomeThing();  
9.   tm.suspend();//挂起当前事务  
10.     methodB();  
11.   //methodB执行完后，复恢第一个事务  
12.   tm.resume(ts1);  
13.doSomeThingB();  
14.   ts1.commit();//提交第一个事务  
15.}  
16.catch(RunTimeException ex){  
17.  ts1.rollback();//回滚第一个事务  
18.}  
19.finally{  
20.  //释放资源  
21.}  
22.} 
main(){
 TransactionManager tm = null;
try{
  //获得一个JTA事务管理器
   tm = getTransactionManager();
   tm.begin();//开启一个新的事务
   Transaction ts1 = tm.getTransaction();
   doSomeThing();
   tm.suspend();//挂起当前事务
     methodB();
   //methodB执行完后，复恢第一个事务
   tm.resume(ts1);
doSomeThingB();
   ts1.commit();//提交第一个事务
}
catch(RunTimeException ex){
  ts1.rollback();//回滚第一个事务
}
finally{
  //释放资源
}
}使用PROPAGATION_NOT_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。

PROPAGATION_NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常


Java代码
1.//事务属性 PROPAGATION_REQUIRED   
2.methodA(){  
3.  doSomeThingA();  
4.methodB();  
5.doSomeThingB();  
6.}  
7. 
8.//事务属性 PROPAGATION_NEVER   
9.methodB(){  
10.  ……  
11.} 
//事务属性 PROPAGATION_REQUIRED
methodA(){
  doSomeThingA();
methodB();
doSomeThingB();
}

//事务属性 PROPAGATION_NEVER
methodB(){
  ……
}单独调用methodB，则非事务的执行。
调用methodA则会抛出异常
throw new IllegalTransactionStateException(
"Transaction propagation 'never' but existing transaction found");


PROPAGATION_NESTED如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行

这是一个嵌套事务,使用JDBC 3.0驱动时,仅仅支持DataSourceTransactionManager作为事务管理器。需要JDBC 驱动的java.sql.Savepoint类。有一些JTA的事务管理器实现可能也提供了同样的功能。

使用PROPAGATION_NESTED，还需要把PlatformTransactionManager的nestedTransactionAllowed属性设为true;
而nestedTransactionAllowed属性值默认为false;

Java代码
1.//事务属性 PROPAGATION_REQUIRED   
2.methodA(){  
3.  doSomeThingA();  
4.methodB();  
5.doSomeThingB();  
6.}  
7. 
8.//事务属性 PROPAGATION_NESTED  
9.methodB(){  
10.  ……  
11.} 
//事务属性 PROPAGATION_REQUIRED
methodA(){
  doSomeThingA();
methodB();
doSomeThingB();
}

//事务属性 PROPAGATION_NESTED
methodB(){
  ……
}
如果单独调用methodB方法，则按REQUIRED属性执行。

如果调用methodA方法，相当于下面的效果

Java代码
1.main(){  
2.Connection con = null;  
3.Savepoint savepoint = null;  
4.try{  
5.  con = getConnection();  
6.  con.setAutoCommit(false);  
7.  doSomeThingA();  
8.  savepoint = con2.setSavepoint();  
9.  try 
10.      methodB();  
11.  }catch(RuntimeException ex){  
12.     con.rollback(savepoint);  
13.  }  
14.  finally{  
15.    //释放资源  
16.  }  
17. 
18.  doSomeThingB();  
19.  con.commit();  
20.}  
21.catch(RuntimeException ex){  
22.  con.rollback();  
23.}  
24.finally{  
25.  //释放资源  
26.}  
27.} 
main(){
Connection con = null;
Savepoint savepoint = null;
try{
  con = getConnection();
  con.setAutoCommit(false);
  doSomeThingA();
  savepoint = con2.setSavepoint();
  try
      methodB();
  }catch(RuntimeException ex){
     con.rollback(savepoint);
  }
  finally{
    //释放资源
  }

  doSomeThingB();
  con.commit();
}
catch(RuntimeException ex){
  con.rollback();
}
finally{
  //释放资源
}
}当methodB方法调用之前，调用setSavepoint方法，保存当前的状态到savepoint。如果methodB方法调用失败，则恢复到之前保存的状态。但是需要注意的是，这时的事务并没有进行提交，如果后续的代码(doSomeThingB()方法)调用失败，则回滚包括methodB方法的所有操作。

嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW的区别:它们非常类似,都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。使用PROPAGATION_REQUIRES_NEW时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务不是一个真正的嵌套事务。同时它需要JTA事务管理器的支持。
使用PROPAGATION_NESTED时，外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚，它是一个真正的嵌套事务。DataSourceTransactionManager使用savepoint支持PROPAGATION_NESTED时，需要JDBC 3.0以上驱动及1.4以上的JDK版本支持。其它的JTA TrasactionManager实现可能有不同的支持方式。

PROPAGATION_REQUIRED应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。

.声明：JavaEye文章版权属于作者，受法律保护。没有作者书面许可不得转载。
推荐链接
?Adobe Flash 平台应用开发大赛 火热进行中
 
返回顶楼  
 
 
 
  
 
shaucle
等级:

文章: 436
积分: 443
来自: 上海

    发表时间：2007-05-11   很清楚，赞一个！ .
返回顶楼  
 
 
 
 
回帖地址 1 0 请登录后投票
 
daquan198163
等级:

文章: 1897
积分: 1501
来自: 吉林->北京->上海

    发表时间：2007-05-11   看了这么多讨论事务的文章，终于有一个说清楚了PROPAGATION_NESTED和幻像读是怎么回事
谢了！ .
返回顶楼  
 
 
 
 
回帖地址 0 0 请登录后投票
 
rainlife
等级:

文章: 692
积分: 1034
来自: 我也来自火星？

    发表时间：2007-05-12   daquan198163 写道
看了这么多讨论事务的文章，终于有一个说清楚了PROPAGATION_NESTED和幻像读是怎么回事
谢了！

嗯，很多地方只是概念性地提一下，难得看到说清楚的好帖。 .
返回顶楼  
 
 
 
 
回帖地址 0 0 请登录后投票
 
klyuan
等级:

文章: 201
积分: 502
来自: 深圳

    发表时间：2007-05-12   谢谢啊！！！呵呵 .
返回顶楼  
 
 
 
 
回帖地址 0 0 请登录后投票
 
shaucle
等级:

文章: 436
积分: 443
来自: 上海

    发表时间：2007-05-12   spring是把Transaction给抽象了,也更好用了
不过前提是jdbc的那几个抽象要先弄明白,不然抽象+抽象就更抽象了.
楼主的文章正好帮助弄明白了这些.
(建议再结合一下原码).

其它方面的抽象如rpc,jndi乃至aop也是如此.
不要因为spring好用就乎略许多其所以然,不然就总是跟着人家的后面跑了. .
返回顶楼  
 
 
 
 
回帖地址 0 0 请登录后投票
 
klyuan
等级:

文章: 201
积分: 502
来自: 深圳

    发表时间：2007-05-14   shaucle 写道
spring是把Transaction给抽象了,也更好用了
不过前提是jdbc的那几个抽象要先弄明白,不然抽象+抽象就更抽象了.
楼主的文章正好帮助弄明白了这些.
(建议再结合一下原码).

其它方面的抽象如rpc,jndi乃至aop也是如此.
不要因为spring好用就乎略许多其所以然,不然就总是跟着人家的后面跑了.


关于spring事务的讨论的确太多了！！！
很多文章谈到事务属性时都写得很简略！甚至有些相关的书籍都刻意的去回避这个问题！！！
特别是很多初学者，对于这些事务属性只能是人云亦云！甚至把aop事务放在哪一层控制都搞不明白！！！

我见过有3年开发经验的程序员还把声明式事务控制放在dao层！！！！
可见是没有理解事务控制！！！！

一定要追溯到问题的本源！！！
.
返回顶楼  
 
 
 
 
回帖地址 1 0 请登录后投票
 
dennis_zane
等级:

文章: 1281
积分: 1728
来自: 杭州

    发表时间：2007-05-14   关于嵌套事务，这篇文章是更好的解释
http://www.javaeye.com/topic/35907 .
返回顶楼  
 
 
 
 
回帖地址 0 0 请登录后投票
 
klyuan
等级:

文章: 201
积分: 502
来自: 深圳

    发表时间：2007-05-14   dennis_zane 写道
关于嵌套事务，这篇文章是更好的解释
http://www.javaeye.com/topic/35907

也是一篇好文！！！
我这个或许更清楚一点。呵呵 .
返回顶楼  
 
 
 
 
回帖地址 0 0 请登录后投票
 
那年夏天
等级: 初级会员

文章: 8
积分: 30
来自: 苏州->上海

    发表时间：2007-05-14   对PROPAGATION_NESTED的介绍很到位，谢谢楼主 .
返回顶楼  
 
 
 
 
回帖地址 0 0 请登录后投票
 

? 上一页 1 2 3 4 5 下一页 ?论坛首页 → Java编程和Java企业应用版 → Spring

跳转论坛:Java编程和Java企业应用 Web前端技术 移动编程和手机应用开发 C/C++编程 Ruby编程 Python编程 PHP编程 Flash编程和RIA Microsoft .Net 综合技术 软件开发和项目管理 行业应用 入门讨论 招聘求职 海阔天空
北京: 当乐网诚聘高薪聘请高级Java程序员 Senior Ja
广东: 思唯奇科技诚聘高薪诚聘高级Swing工程师
上海: 北京银证软件诚聘JAVA开发工程师
湖北: DIB 迪博诚聘JAVA高级软件工程师
北京: JavaEye猎头诚聘Java搜索工程师
北京: 去哪儿旅游搜索引擎诚聘java开发工程师
上海: JavaEye猎头诚聘30万起年薪诚聘平台高级架构
北京: 祖睿科技诚聘Senior Java Engineer
  首页新闻论坛问答专栏博客文摘圈子招聘服务搜索JavaWebRubyPython敏捷MySQL润亁报表图书.广告服务JavaEye黑板报关于我们联系我们友情链接? 2003-2010 JavaEye.com. 上海炯耐计算机软件有限公司版权所有 [ 沪ICP备05023328号 ] 

majinlongjinlong
关注
Spring入门教程.rar
12-31
Spring入门教程.rar Spring入门教程.rar Spring入门教程.rar
Spring入门教程
热门推荐
纷纷雪落
03-28 3万+
Spring入门教程                                     1．Spring简介（1）Spring是什么Spring是轻量级的J2EE应用程序开源框架。它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性
Spring（看这一篇就够了）
最新发布
m0_74436895的博客
08-01 1450
Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制反转）和AOP（面向切面）为思想内核，提供了控制层SpringMVC、数据层SpringData、服务层事务管理等众多技术，并可以整合众多第三方框架。Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。Spring官网地址：https://spring.io/.\ Spring框架根据不同的功能被划分成了多个模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使
Spring——入门
Gavin
03-11 4026
Spring是什么？ Struts是Web框架 Hibernate是ORM框架，处于持久层 Spring是容器框架，用于配置Bean，并维护Bean之间关系的一种框架。 Spring中有一个非常重要的概念：Bean，Bean是Java中的任何一种对象，它可以是JavaBean、可以是Service，可以是Action，也可以是DAO 重要的概念：IOC（控制反转，...
Spring 最全入门教程详解
lucky_fd的博客
07-04 7358
Spring 基础框架，可以视为Spring 基础设施，基本上任何其他 Spring 项目都是以 SpringFramework 为基础的。Spring 5 的模块结构图: lOC: Inversion of Control，翻译过来是反转控制。把对象创建和对象之间的调用过程，交给 Spring 进行管理Spring 的IOC 容器就是IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IOC容器。Spring 提供了IOC容器的两种实现方式：
Spring 入门教程
Oneby的博客
03-01 1万+
Spring 入门教程 1、参考资料 尚硅谷-Spring5框架最新版教程（idea版） 雷丰阳spring、springmvc、mybatis、spring一站式学习 项目地址：oneby1314/spring-learn 2、Spring 概述 2.1、Spring 框架概述 Spring 是轻量级的开源的 JavaEE 框架 Spring 为简化企业级开发而生，使用Spring，Javabean就可以实现很多以前要靠EJB才能实现的功能 Spring 有两个核心部分：IOC 和 AOP
SpringCloud基础教程
12-31
本基础教程旨在帮助初学者全面理解并掌握SpringCloud的核心概念和技术，通过实践源码与配套文档，深入学习其工作原理和应用方式。 首先，我们需要了解SpringCloud的基础架构，它由多个子项目组成，如Eureka（服务...
JAVA中spring入门教程.zipJAVA中spring入门教程.zipJAVA中spring入门教程.zip
03-05
Spring框架是Java开发中的核心组件，它为构建企业级应用...通过深入学习并实践这些Spring框架的核心概念和技术，开发者可以有效地提高Java应用的开发效率和质量，为构建可扩展、易维护的大型企业级应用打下坚实的基础。
Spring入门教程.pdf
09-30
### Spring入门教程知识点详解 #### 一、理论知识 ##### 1. 依赖注入与控制反转 - **依赖注入**（Dependency Injection, DI）：在应用程序的运行期间，由外部容器（例如Spring容器）动态地将一个对象所依赖的其他...
2023最新《Spring Boot基础教程》
10-11
Spring Boot 2.x基础教程：快速入门 Spring Boot 2.x基础教程：工程结构推荐 配置详解 Spring Boot 2.x基础教程：配置文件详解 Spring Boot 2.x基础教程：2.4版本前后的多环境配置变化 Spring Boot 2.x基础教程：2.4...
spring入门教程书籍
07-24
本入门教程书籍旨在帮助新手快速掌握Spring的基本概念和实践应用。 《Spring 3.x企业应用开发实战》这本书可能包含了以下知识点： 1. **Spring概述**：介绍Spring框架的历史、设计理念以及它在企业级应用开发中的...
spring绝佳入门教程.pdf
06-21
spring绝佳入门教程.pdf。。
spring详细教程
02-04
八维教育spring课程 笔记，详细介绍了，spring的全套框架体系，不包括springboot springcloude
Spring新手教程
青玉白露的博客
05-22 605
基于《Spring实战》第五版进行学习 让我们来一起学习Java Spring吧！ Spring基础 介绍 Spring 的核心是一个容器，通常称为 Spring 应用程序上下文，用于创建和管理应用程序组件。**这些组件（或 bean）**在 Spring 应用程序上下文中连接在一起以构成一个完整的应用程序。 将 bean 连接在一起的行为是基于一种称为 依赖注入（DI）的模式。依赖项注入的应用程序不是由组件自身创建和维护它们依赖的其他 bean 的生命周期，而是依赖于单独的实体（容器）来创建和维护所有.
Spring详细教程入门(一)
qq_33408235的博客
10-20 2640
1. Spring 的概述 1.1 什么是 Spring pring 是一个开源框架，Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构
Spring框架入门学习教程---从无到有，一次学明白！
assdfgdfgjhtdo的博客
08-31 345
Spring通过PlatformTransactionManager平台事务管理器接口对事务的管理进行高度抽象，但是该接口下具体的实现是由各个平台自己实现，Spring并不直接管理事务，而是提供了多种事务管理器，也就是对各个平台的事务管理进行封装，最终将事务管理的职责委托给JDBC、Hibernate、JPA、JMS、MongoDB等持久化平台框架的事务来实现。 一、认识Spring Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发 的复杂性而创建的。.
Spring MVC入门教程：从基础到实践
Spring MVC入门教程 Spring MVC是基于Java的Web应用程序开发框架，作为 Spring Framework的一部分，提供了一个灵活的MVC架构，用于构建Web应用程序。在本教程中，我们将从基本概念开始，逐步深入到Spring MVC的各个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值