62,614
社区成员
发帖
与我相关
我的任务
分享请发表友善的回复…
发表回复
In8 2010-09-20
- 打赏
- 举报
学习LE
xuzhen1984 2009-01-12
- 打赏
- 举报
我晕。
这个很难回答
这个很难回答
guanly_025 2009-01-12
- 打赏
- 举报
[Quote=引用 13 楼 clarck_913 的回复:]
AOP是面向切面的编程
在Spring里，只有面向方法的切面。
比如你有一个方法A和方法B，你希望在A执行前执行方法B，但不能把B的代码贴到A中
因为和A类似的方法有很多，如果你全都贴过去的话，工作量大并且是重复的工作
这个时候你就定义了A为切面，B为处理程序。Spring 会在你调用A方法时自动执行B方法
实际过程是Spring 为含有A方法的类生成了一个代理类，该类也有一个叫A的方法但其实现却是 B+A的实现
你调用A的…
[/Quote]这个说的好
AOP是面向切面的编程
在Spring里，只有面向方法的切面。
比如你有一个方法A和方法B，你希望在A执行前执行方法B，但不能把B的代码贴到A中
因为和A类似的方法有很多，如果你全都贴过去的话，工作量大并且是重复的工作
这个时候你就定义了A为切面，B为处理程序。Spring 会在你调用A方法时自动执行B方法
实际过程是Spring 为含有A方法的类生成了一个代理类，该类也有一个叫A的方法但其实现却是 B+A的实现
你调用A的…
[/Quote]这个说的好
likgui 2009-01-08
- 打赏
- 举报
学习了
eggcanfly 2009-01-06
- 打赏
- 举报
[Quote=引用 13 楼 clarck_913 的回复:]
AOP是面向切面的编程
在Spring里，只有面向方法的切面。
比如你有一个方法A和方法B，你希望在A执行前执行方法B，但不能把B的代码贴到A中
因为和A类似的方法有很多，如果你全都贴过去的话，工作量大并且是重复的工作
这个时候你就定义了A为切面，B为处理程序。Spring 会在你调用A方法时自动执行B方法
实际过程是Spring 为含有A方法的类生成了一个代理类，该类也有一个叫A的方法但其实现却是 B+A的实现
你调用A的时候，…
[/Quote]
您说的真好
AOP是面向切面的编程
在Spring里，只有面向方法的切面。
比如你有一个方法A和方法B，你希望在A执行前执行方法B，但不能把B的代码贴到A中
因为和A类似的方法有很多，如果你全都贴过去的话，工作量大并且是重复的工作
这个时候你就定义了A为切面，B为处理程序。Spring 会在你调用A方法时自动执行B方法
实际过程是Spring 为含有A方法的类生成了一个代理类，该类也有一个叫A的方法但其实现却是 B+A的实现
你调用A的时候，…
[/Quote]
您说的真好
jedeyjiang 2008-12-25
- 打赏
- 举报
AOP编程就是切面编程
方法执行前，执行后，以及环绕执行过程中调用增强代码。
它的底层实现是
1.JDK动态代理（如果实现了某一借口）
2.CGLIB字节码增强（可以强制使用）
方法执行前，执行后，以及环绕执行过程中调用增强代码。
它的底层实现是
1.JDK动态代理（如果实现了某一借口）
2.CGLIB字节码增强（可以强制使用）
East271536394 2008-12-22
- 打赏
- 举报
转一个给你吧：
一.为什么要用框架和模式
1.为什么要用模式？
因为模式是一种指导，在一个良好的指导下，有助于你完成任务，有助于你作出一个优良的设计方案，达到事半功倍的效果。而且会得到解决问题的最佳办法。
2.为什么要用框架？
因为软件系统发展到今天已经很复杂了，特别是服务器端软件，设计到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。
总之:就是让开发更简单,让我们成功
二. AOP
1. AOP是什么？
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
2. 切面意义何在？
就可以在这层切面上进行统一的集中式权限管理。而业务逻辑组件则无需关心权限方面的问题。也就是说，通过切面，我们可以将系统中各个不同层次上的问题隔离开来，实现统一集约式处理。各切面只需集中于自己领域内的逻辑实现。这一方面使得开发逻辑更加清晰，专业化分工更加易于进行；另一方面，由于切面的隔离，降低了耦合性，我们就可以在不同的应用中将各个切面组合使用，从而使得代码可重用性大大增强。
3. AOP应用范围
Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading 懒加载
Debugging 调试
logging, tracing, profiling and monitoring 记录跟踪 优化 校准
Performance optimization 性能优化
Persistence 持久化
Resource pooling 资源池
Synchronization 同步
Transactions 事务
三.Spring事务处理
1.Spring事务管理能给我们带来什么?
对于传统的基于特定事务资源的事务处理而言（如基于JDBC 的数据库访问），Spring并不会对其产生什么影响，我们照样可以成功编写并运行这样的代码。同时，Spring还提供了一些辅助类可供我们选择使用，这些辅助类简化了传统的数据库操作流程，在一定程度上节省了工作量，提高了编码效率。
对于依赖容器的参数化事务管理而言，Spring则表现出了极大的价值。Spring本身也是一个容器，只是相对EJB容器而言，Spring显得更为轻便小巧。我们无需付出其他方面的代价，即可通过Spring实现基于容器的事务管理（本质上来讲，Spring的事务管理是基于动态AOP）。
2. Hibernate in Spring
applicationContext.xml
UserDAO.java ArticleDAO.java
public class UserDAOImpl extends HibernateDaoSupport implements UserDAO { public void saveUser(Tuser user) {
getHibernateTemplate().saveOrUpdate(user);
}
}
public class ArticleDAOImpl extends HibernateDaoSupport implements ArticleDAO {
public void saveArticle(Article article) {
getHibernateTemplate().saveOrUpdate(article);
}
}
HibernateDaoSupport
实现了HibernateTemplate和SessionFactory实例的关联。HibernateTemplate对Hibernate Session操作进行了封装，而HibernateTemplate.execute方法则是一封装机制的核心，感兴趣可以研究一下其实现机制。
借助HibernateTemplate我们可以脱离每次数据操作必须首先获得Session实例、启动事务、提交/回滚事务以及烦杂的try/catch/finally的繁琐操作。从而获得以上代码中精干集中的逻辑呈现效果。
org.mzone.service.impl.UserManagerImpl
public class UserManagerImpl implements UserManager {
private UserDAO userDao;
private ArticleDAO articleDao;
public void saveUserAndArticle(Tuser user, Article article) {
userDao.saveUser(user);
articleDao.saveArticle(article);
}
}
测试代码
InputStream is = new FileInputStream("applicationContext.xml");
XmlBeanFactory factory = new XmlBeanFactory(is);
UserManager userManager = (UserManager )factory.getBean(" baseTxProxy ");
user = new Tuser();
article = new Article();
user.setUsername("hellboys_topic 1");
user.setPassword("12345678_topic 1");
article.setTitle("hellboys_topic 1");
article.setContent("hellboys_topic 1");
userManager.saveUserAndArticle(user,article);
注意问题
UserManager userManager = (UserManager )factory.getBean("baseTxProxy ");
UserManager userManager = (UserManagerImpl) ctx.getBean("baseTxProxy");
java.lang.ClassCastException
原因在于Spring的AOP实现机制，前面曾经提及，Spring中的事务管理实际上是基于动态AOP机制实现，为了实现动态AOP，Spring在默认情况下会使用Java DynamicProxy，但是，Dynamic Proxy要求其代理的对象必须实现一个接口，该接口定义了准备进行代理的方法。而对于没有实现任何接口的Java Class，需要采用其他方式，Spring通过CGLib10实现这一功能。
CGLib可以在运行期对Class行为进行修改。由于其功能强大，性能出众，常常被作为Java Dynamic Proxy之外的动态Proxy模式的实现基础。在Spring、Hibernate中都用到了CGLib类库。
一.为什么要用框架和模式
1.为什么要用模式？
因为模式是一种指导，在一个良好的指导下，有助于你完成任务，有助于你作出一个优良的设计方案，达到事半功倍的效果。而且会得到解决问题的最佳办法。
2.为什么要用框架？
因为软件系统发展到今天已经很复杂了，特别是服务器端软件，设计到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。
总之:就是让开发更简单,让我们成功
二. AOP
1. AOP是什么？
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
2. 切面意义何在？
就可以在这层切面上进行统一的集中式权限管理。而业务逻辑组件则无需关心权限方面的问题。也就是说，通过切面，我们可以将系统中各个不同层次上的问题隔离开来，实现统一集约式处理。各切面只需集中于自己领域内的逻辑实现。这一方面使得开发逻辑更加清晰，专业化分工更加易于进行；另一方面，由于切面的隔离，降低了耦合性，我们就可以在不同的应用中将各个切面组合使用，从而使得代码可重用性大大增强。
3. AOP应用范围
Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading 懒加载
Debugging 调试
logging, tracing, profiling and monitoring 记录跟踪 优化 校准
Performance optimization 性能优化
Persistence 持久化
Resource pooling 资源池
Synchronization 同步
Transactions 事务
三.Spring事务处理
1.Spring事务管理能给我们带来什么?
对于传统的基于特定事务资源的事务处理而言（如基于JDBC 的数据库访问），Spring并不会对其产生什么影响，我们照样可以成功编写并运行这样的代码。同时，Spring还提供了一些辅助类可供我们选择使用，这些辅助类简化了传统的数据库操作流程，在一定程度上节省了工作量，提高了编码效率。
对于依赖容器的参数化事务管理而言，Spring则表现出了极大的价值。Spring本身也是一个容器，只是相对EJB容器而言，Spring显得更为轻便小巧。我们无需付出其他方面的代价，即可通过Spring实现基于容器的事务管理（本质上来讲，Spring的事务管理是基于动态AOP）。
2. Hibernate in Spring
applicationContext.xml
UserDAO.java ArticleDAO.java
public class UserDAOImpl extends HibernateDaoSupport implements UserDAO { public void saveUser(Tuser user) {
getHibernateTemplate().saveOrUpdate(user);
}
}
public class ArticleDAOImpl extends HibernateDaoSupport implements ArticleDAO {
public void saveArticle(Article article) {
getHibernateTemplate().saveOrUpdate(article);
}
}
HibernateDaoSupport
实现了HibernateTemplate和SessionFactory实例的关联。HibernateTemplate对Hibernate Session操作进行了封装，而HibernateTemplate.execute方法则是一封装机制的核心，感兴趣可以研究一下其实现机制。
借助HibernateTemplate我们可以脱离每次数据操作必须首先获得Session实例、启动事务、提交/回滚事务以及烦杂的try/catch/finally的繁琐操作。从而获得以上代码中精干集中的逻辑呈现效果。
org.mzone.service.impl.UserManagerImpl
public class UserManagerImpl implements UserManager {
private UserDAO userDao;
private ArticleDAO articleDao;
public void saveUserAndArticle(Tuser user, Article article) {
userDao.saveUser(user);
articleDao.saveArticle(article);
}
}
测试代码
InputStream is = new FileInputStream("applicationContext.xml");
XmlBeanFactory factory = new XmlBeanFactory(is);
UserManager userManager = (UserManager )factory.getBean(" baseTxProxy ");
user = new Tuser();
article = new Article();
user.setUsername("hellboys_topic 1");
user.setPassword("12345678_topic 1");
article.setTitle("hellboys_topic 1");
article.setContent("hellboys_topic 1");
userManager.saveUserAndArticle(user,article);
注意问题
UserManager userManager = (UserManager )factory.getBean("baseTxProxy ");
UserManager userManager = (UserManagerImpl) ctx.getBean("baseTxProxy");
java.lang.ClassCastException
原因在于Spring的AOP实现机制，前面曾经提及，Spring中的事务管理实际上是基于动态AOP机制实现，为了实现动态AOP，Spring在默认情况下会使用Java DynamicProxy，但是，Dynamic Proxy要求其代理的对象必须实现一个接口，该接口定义了准备进行代理的方法。而对于没有实现任何接口的Java Class，需要采用其他方式，Spring通过CGLib10实现这一功能。
CGLib可以在运行期对Class行为进行修改。由于其功能强大，性能出众，常常被作为Java Dynamic Proxy之外的动态Proxy模式的实现基础。在Spring、Hibernate中都用到了CGLib类库。
bobskay 2008-12-20
- 打赏
- 举报
网上资料那么多,随便google一下就可以了,lz问的这么笼统让人怎么回答
leo_bogard 2008-12-08
- 打赏
- 举报
up
aiqinhai621 2008-12-07
- 打赏
- 举报
<!--事务配置开始-->
<!--hibernate transaction [start]-->
<!-- declare transaction hibernate [start] (事务分二种，以下为声明式事务) -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory"/>
</property>
</bean>
<bean id="exampler1_service" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref local="transactionManager"/>
</property>
<property name="target">
<ref local="CustomersDAO"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="get*">
PROPAGATION_REQUIRED,readOnly
</prop>
<prop key="set*">
PROPAGATION_REQUIRED,readOnly
</prop>
<prop key="save">
PROPAGATION_REQUIRED,readOnly
</prop>
</props>
</property>
</bean>
<!--hibernate transaction [end]-->
<!-- declare transaction hibernate [end] -->
<!-- programing transaction hibernate (编程式事务) [start] -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager">
<ref local="transactionManager"/>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory"/>
</property>
</bean>
<!-- programing transaction hibernate [end] -->
<!--其它事务配置-->
<!-- JDBC TransactionManager [start]-->
<bean id="transactionManager_jdbc" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource_jdbc"/>
</property>
</bean>
<bean id="dataSource_jdbc" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
<value>java:/MySqlDs</value>
</property>
</bean>
<!--JDBC TransactionManager [end] -->
<!-- JDO TransactionManager [start]-->
<bean id="transactionManager_jdo" class="org.springframework.orm.jdo.JdoTransactionManager">
<property name="persistenceManagerFactory">
<ref local="dataSource_jdbc"/>
</property>
</bean>
<!-- JDO TransactionManager [end] -->
<!-- JTA TransactionManager [start]-->
<bean id="transactionManager_jta" class="org.springframework.transaction.jta.JtaTransactionManager">
<property name="userTransactionName">
<value>java:comp/UserTransaction</value>
</property>
</bean>
<!-- JTA TransactionManager [end] -->
<!--事务配置结束-->
<!--hibernate transaction [start]-->
<!-- declare transaction hibernate [start] (事务分二种，以下为声明式事务) -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory"/>
</property>
</bean>
<bean id="exampler1_service" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref local="transactionManager"/>
</property>
<property name="target">
<ref local="CustomersDAO"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="get*">
PROPAGATION_REQUIRED,readOnly
</prop>
<prop key="set*">
PROPAGATION_REQUIRED,readOnly
</prop>
<prop key="save">
PROPAGATION_REQUIRED,readOnly
</prop>
</props>
</property>
</bean>
<!--hibernate transaction [end]-->
<!-- declare transaction hibernate [end] -->
<!-- programing transaction hibernate (编程式事务) [start] -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager">
<ref local="transactionManager"/>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory"/>
</property>
</bean>
<!-- programing transaction hibernate [end] -->
<!--其它事务配置-->
<!-- JDBC TransactionManager [start]-->
<bean id="transactionManager_jdbc" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource_jdbc"/>
</property>
</bean>
<bean id="dataSource_jdbc" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
<value>java:/MySqlDs</value>
</property>
</bean>
<!--JDBC TransactionManager [end] -->
<!-- JDO TransactionManager [start]-->
<bean id="transactionManager_jdo" class="org.springframework.orm.jdo.JdoTransactionManager">
<property name="persistenceManagerFactory">
<ref local="dataSource_jdbc"/>
</property>
</bean>
<!-- JDO TransactionManager [end] -->
<!-- JTA TransactionManager [start]-->
<bean id="transactionManager_jta" class="org.springframework.transaction.jta.JtaTransactionManager">
<property name="userTransactionName">
<value>java:comp/UserTransaction</value>
</property>
</bean>
<!-- JTA TransactionManager [end] -->
<!--事务配置结束-->
clarck_913 2008-12-07
- 打赏
- 举报
AOP是面向切面的编程
在Spring里，只有面向方法的切面。
比如你有一个方法A和方法B，你希望在A执行前执行方法B，但不能把B的代码贴到A中
因为和A类似的方法有很多，如果你全都贴过去的话，工作量大并且是重复的工作
这个时候你就定义了A为切面，B为处理程序。Spring 会在你调用A方法时自动执行B方法
实际过程是Spring 为含有A方法的类生成了一个代理类，该类也有一个叫A的方法但其实现却是 B+A的实现
你调用A的时候，调用的对象是代理对象，但是你并不知道。
事务的编程正是上述情况的典型
事务处理代码是B(提交，回滚)，事务执行代码是A(增删改查)
在Spring 中已经内置了事务处理代码，也就是B，所以我们写A方法，然后配置事务就可以了。
在Spring里，只有面向方法的切面。
比如你有一个方法A和方法B，你希望在A执行前执行方法B，但不能把B的代码贴到A中
因为和A类似的方法有很多，如果你全都贴过去的话，工作量大并且是重复的工作
这个时候你就定义了A为切面，B为处理程序。Spring 会在你调用A方法时自动执行B方法
实际过程是Spring 为含有A方法的类生成了一个代理类，该类也有一个叫A的方法但其实现却是 B+A的实现
你调用A的时候，调用的对象是代理对象，但是你并不知道。
事务的编程正是上述情况的典型
事务处理代码是B(提交，回滚)，事务执行代码是A(增删改查)
在Spring 中已经内置了事务处理代码，也就是B，所以我们写A方法，然后配置事务就可以了。
SINCE1978 2008-12-07
- 打赏
- 举报
“Spring 用到的实际上是事务上下文模式，把事务的边界定为业务层，也就是一个业务逻辑作为一个事务的整体，
当然了这个业务逻辑方法还可以调用其他的业务逻辑方法，每个业务逻辑方法可以调用若干 DAO 方法与数据库
进行交互。
Spring 在 AOP 中开启事务，接着调用方法，方法调用完成后提交事务，出现异常时回滚事务。具体的切入点在
方法调用前、方法调用后和抛出异常时等三处。
我对 Spring 不熟，在这里只能谈一下我的观点。
要想把多个 DAO 中的 JDBC Connection 对象纳入一个事务中，那么 Connection 就不能由 DAO 来管理，也就是
说事务的边界不能放在 DAO 层中，得把事务边界定在业务层中，这样才可以保证一个业务逻辑是原子性的。这样
的话就得保证所调用一个业务逻辑中所有的 DAO 方法都是共用一个 Connection 的，这样才能保证将这些 DAO
操作纳入到一个事务当中。DAO 的 Connection 一般从 ThreadLocal 这个类中获得，这样可以保证同一个线程使
用同一个 Connection。而 ThreadLocal 中的 Connection 是使用 AOP 的方式在调用方法之前就已经处理好的了，
而且其中的 Connection 已经关闭了自动提交功能，这样的话就可以将一个业务方法作为事务的边界启用事务了。
当然了，业务逻辑中的业务方法是不能直接让调用者来管理的，必须让某一个程序（容器）来管理，这样才有可
能使用 AOP 的代理对象。
实际上这里面的东西相当复杂，比如说，A，B，C 三个业务逻辑方法，每个方法中有若干个 DAO 操作，A 方法中
使用到了 B 和 C 方法，如果单独调用 B 或者 C 方法时在调用完后是提交事务的，但是调用 A 方法时，B 和 C
中的事务得合并到 A 中的事务中去，并不能执行完 B 或者 C 后就直接提交了。”
实际当中没那么复杂，可能金融方面的倚重数据库而且业务逻辑非常复杂的可能会有吧。现在数据库只是一种数据持久化手段，一般仅仅是对一张或几张表增删改查而已。spring事务管理的使用代码个人感觉比较丑陋，声明式事务没太大必要，导致配置文件和类无谓的增多，画蛇添足。之所以这样个人认为还是spring团队需要这样的“亮点”，因为它们的宣传就是针对旧EJB：你看、旧的EJB需要在容器里运行、配置复杂、侵入。我无需容器、配置相对简单、无侵入、可以给任何pojo以配置方式加入事务能力...，事务管理有必要这么复杂吗？不就是connection.setAutoCommit(false)吗。实际上spring的这个问题一直存在，因为spring还是比较“单薄”的，struts解决了展现层、hibernate解决了持久层，而且二者都深深涉入中间层，但是spring并未解决哪一层，spring东西太少、显得非常“单薄”。spring团队也明白这一点，从spring诞生之日开始，就对spring精心包装、宣传，提出所谓的ioc这种空洞的“理论”，而且逐步增加spring的功能：aop、acegi...正是spring团队明白spring的单薄所以才一直积极的引入额外功能。
当然了这个业务逻辑方法还可以调用其他的业务逻辑方法，每个业务逻辑方法可以调用若干 DAO 方法与数据库
进行交互。
Spring 在 AOP 中开启事务，接着调用方法，方法调用完成后提交事务，出现异常时回滚事务。具体的切入点在
方法调用前、方法调用后和抛出异常时等三处。
我对 Spring 不熟，在这里只能谈一下我的观点。
要想把多个 DAO 中的 JDBC Connection 对象纳入一个事务中，那么 Connection 就不能由 DAO 来管理，也就是
说事务的边界不能放在 DAO 层中，得把事务边界定在业务层中，这样才可以保证一个业务逻辑是原子性的。这样
的话就得保证所调用一个业务逻辑中所有的 DAO 方法都是共用一个 Connection 的，这样才能保证将这些 DAO
操作纳入到一个事务当中。DAO 的 Connection 一般从 ThreadLocal 这个类中获得，这样可以保证同一个线程使
用同一个 Connection。而 ThreadLocal 中的 Connection 是使用 AOP 的方式在调用方法之前就已经处理好的了，
而且其中的 Connection 已经关闭了自动提交功能，这样的话就可以将一个业务方法作为事务的边界启用事务了。
当然了，业务逻辑中的业务方法是不能直接让调用者来管理的，必须让某一个程序（容器）来管理，这样才有可
能使用 AOP 的代理对象。
实际上这里面的东西相当复杂，比如说，A，B，C 三个业务逻辑方法，每个方法中有若干个 DAO 操作，A 方法中
使用到了 B 和 C 方法，如果单独调用 B 或者 C 方法时在调用完后是提交事务的，但是调用 A 方法时，B 和 C
中的事务得合并到 A 中的事务中去，并不能执行完 B 或者 C 后就直接提交了。”
实际当中没那么复杂，可能金融方面的倚重数据库而且业务逻辑非常复杂的可能会有吧。现在数据库只是一种数据持久化手段，一般仅仅是对一张或几张表增删改查而已。spring事务管理的使用代码个人感觉比较丑陋，声明式事务没太大必要，导致配置文件和类无谓的增多，画蛇添足。之所以这样个人认为还是spring团队需要这样的“亮点”，因为它们的宣传就是针对旧EJB：你看、旧的EJB需要在容器里运行、配置复杂、侵入。我无需容器、配置相对简单、无侵入、可以给任何pojo以配置方式加入事务能力...，事务管理有必要这么复杂吗？不就是connection.setAutoCommit(false)吗。实际上spring的这个问题一直存在，因为spring还是比较“单薄”的，struts解决了展现层、hibernate解决了持久层，而且二者都深深涉入中间层，但是spring并未解决哪一层，spring东西太少、显得非常“单薄”。spring团队也明白这一点，从spring诞生之日开始，就对spring精心包装、宣传，提出所谓的ioc这种空洞的“理论”，而且逐步增加spring的功能：aop、acegi...正是spring团队明白spring的单薄所以才一直积极的引入额外功能。
chaorenwopashei 2008-12-04
- 打赏
- 举报
从数据库里面学习去
火龙果被占用了 2008-12-03
- 打赏
- 举报
Spring 用到的实际上是事务上下文模式，把事务的边界定为业务层，也就是一个业务逻辑作为一个事务的整体，
当然了这个业务逻辑方法还可以调用其他的业务逻辑方法，每个业务逻辑方法可以调用若干 DAO 方法与数据库
进行交互。
Spring 在 AOP 中开启事务，接着调用方法，方法调用完成后提交事务，出现异常时回滚事务。具体的切入点在
方法调用前、方法调用后和抛出异常时等三处。
我对 Spring 不熟，在这里只能谈一下我的观点。
要想把多个 DAO 中的 JDBC Connection 对象纳入一个事务中，那么 Connection 就不能由 DAO 来管理，也就是
说事务的边界不能放在 DAO 层中，得把事务边界定在业务层中，这样才可以保证一个业务逻辑是原子性的。这样
的话就得保证所调用一个业务逻辑中所有的 DAO 方法都是共用一个 Connection 的，这样才能保证将这些 DAO
操作纳入到一个事务当中。DAO 的 Connection 一般从 ThreadLocal 这个类中获得，这样可以保证同一个线程使
用同一个 Connection。而 ThreadLocal 中的 Connection 是使用 AOP 的方式在调用方法之前就已经处理好的了，
而且其中的 Connection 已经关闭了自动提交功能，这样的话就可以将一个业务方法作为事务的边界启用事务了。
当然了，业务逻辑中的业务方法是不能直接让调用者来管理的，必须让某一个程序（容器）来管理，这样才有可
能使用 AOP 的代理对象。
实际上这里面的东西相当复杂，比如说，A，B，C 三个业务逻辑方法，每个方法中有若干个 DAO 操作，A 方法中
使用到了 B 和 C 方法，如果单独调用 B 或者 C 方法时在调用完后是提交事务的，但是调用 A 方法时，B 和 C
中的事务得合并到 A 中的事务中去，并不能执行完 B 或者 C 后就直接提交了。
当然了这个业务逻辑方法还可以调用其他的业务逻辑方法，每个业务逻辑方法可以调用若干 DAO 方法与数据库
进行交互。
Spring 在 AOP 中开启事务，接着调用方法，方法调用完成后提交事务，出现异常时回滚事务。具体的切入点在
方法调用前、方法调用后和抛出异常时等三处。
我对 Spring 不熟，在这里只能谈一下我的观点。
要想把多个 DAO 中的 JDBC Connection 对象纳入一个事务中，那么 Connection 就不能由 DAO 来管理，也就是
说事务的边界不能放在 DAO 层中，得把事务边界定在业务层中，这样才可以保证一个业务逻辑是原子性的。这样
的话就得保证所调用一个业务逻辑中所有的 DAO 方法都是共用一个 Connection 的，这样才能保证将这些 DAO
操作纳入到一个事务当中。DAO 的 Connection 一般从 ThreadLocal 这个类中获得，这样可以保证同一个线程使
用同一个 Connection。而 ThreadLocal 中的 Connection 是使用 AOP 的方式在调用方法之前就已经处理好的了，
而且其中的 Connection 已经关闭了自动提交功能，这样的话就可以将一个业务方法作为事务的边界启用事务了。
当然了，业务逻辑中的业务方法是不能直接让调用者来管理的，必须让某一个程序（容器）来管理，这样才有可
能使用 AOP 的代理对象。
实际上这里面的东西相当复杂，比如说，A，B，C 三个业务逻辑方法，每个方法中有若干个 DAO 操作，A 方法中
使用到了 B 和 C 方法，如果单独调用 B 或者 C 方法时在调用完后是提交事务的，但是调用 A 方法时，B 和 C
中的事务得合并到 A 中的事务中去，并不能执行完 B 或者 C 后就直接提交了。
dengfeiling 2008-12-02
- 打赏
- 举报
在方法执行前事务开始, 执行后提交.
当然事务方面也涉及到事务传播什么的.
自己看看吧
当然事务方面也涉及到事务传播什么的.
自己看看吧
chaorenwopashei 2008-12-02
- 打赏
- 举报
InputStream is = new FileInputStream("applicationContext.xml");
XmlBeanFactory factory = new XmlBeanFactory(is);
UserManager userManager = (UserManager )factory.getBean(" baseTxProxy ");
user = new Tuser();
article = new Article();
user.setUsername("hellboys_topic 1");
user.setPassword("12345678_topic 1");
article.setTitle("hellboys_topic 1");
article.setContent("hellboys_topic 1");
userManager.saveUserAndArticle(user,article);
InputStream is = new FileInputStream("web.xml");
XmlBeanFactory factory = new XmlBeanFactory(is);
UserManager userManager = (UserManager)factory.getBean("baseTxProxy");
user = newTuser();
article = new Article();
user.setUsername("fasdf");
userManager.saveUserAndArticle(user,article);
XmlBeanFactory factory = new XmlBeanFactory(is);
UserManager userManager = (UserManager )factory.getBean(" baseTxProxy ");
user = new Tuser();
article = new Article();
user.setUsername("hellboys_topic 1");
user.setPassword("12345678_topic 1");
article.setTitle("hellboys_topic 1");
article.setContent("hellboys_topic 1");
userManager.saveUserAndArticle(user,article);
InputStream is = new FileInputStream("web.xml");
XmlBeanFactory factory = new XmlBeanFactory(is);
UserManager userManager = (UserManager)factory.getBean("baseTxProxy");
user = newTuser();
article = new Article();
user.setUsername("fasdf");
userManager.saveUserAndArticle(user,article);
Andy__Huang 2008-12-02
- 打赏
- 举报
好!
cy729215495 2008-12-02
- 打赏
- 举报
这种东西随便哪边将spring的书都有答案,不过既然是在论坛上问,我们回帖的把书上的东西,讲的一些大道理拿给人看不妥当,还是用自己的话说最好了!
我比较赞同4楼的话.
我比较赞同4楼的话.
sanhuaixuan 2008-12-01
- 打赏
- 举报
1. AOP是什么？
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
2. 切面意义何在？
就可以在这层切面上进行统一的集中式权限管理。而业务逻辑组件则无需关心权限方面的问题。也就是说，通过切面，我们可以将系统中各个不同层次上的问题隔离开来，实现统一集约式处理。各切面只需集中于自己领域内的逻辑实现。这一方面使得开发逻辑更加清晰，专业化分工更加易于进行；另一方面，由于切面的隔离，降低了耦合性，我们就可以在不同的应用中将各个切面组合使用，从而使得代码可重用性大大增强。
3. AOP应用范围
Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading 懒加载
Debugging 调试
logging, tracing, profiling and monitoring 记录跟踪 优化 校准
Performance optimization 性能优化
Persistence 持久化
Resource pooling 资源池
Synchronization 同步
Transactions 事务
三.Spring事务处理
1.Spring事务管理能给我们带来什么?
对于传统的基于特定事务资源的事务处理而言（如基于JDBC 的数据库访问），Spring并不会对其产生什么影响，我们照样可以成功编写并运行这样的代码。同时，Spring还提供了一些辅助类可供我们选择使用，这些辅助类简化了传统的数据库操作流程，在一定程度上节省了工作量，提高了编码效率。
对于依赖容器的参数化事务管理而言，Spring则表现出了极大的价值。Spring本身也是一个容器，只是相对EJB容器而言，Spring显得更为轻便小巧。我们无需付出其他方面的代价，即可通过Spring实现基于容器的事务管理（本质上来讲，Spring的事务管理是基于动态AOP）。
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
2. 切面意义何在？
就可以在这层切面上进行统一的集中式权限管理。而业务逻辑组件则无需关心权限方面的问题。也就是说，通过切面，我们可以将系统中各个不同层次上的问题隔离开来，实现统一集约式处理。各切面只需集中于自己领域内的逻辑实现。这一方面使得开发逻辑更加清晰，专业化分工更加易于进行；另一方面，由于切面的隔离，降低了耦合性，我们就可以在不同的应用中将各个切面组合使用，从而使得代码可重用性大大增强。
3. AOP应用范围
Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading 懒加载
Debugging 调试
logging, tracing, profiling and monitoring 记录跟踪 优化 校准
Performance optimization 性能优化
Persistence 持久化
Resource pooling 资源池
Synchronization 同步
Transactions 事务
三.Spring事务处理
1.Spring事务管理能给我们带来什么?
对于传统的基于特定事务资源的事务处理而言（如基于JDBC 的数据库访问），Spring并不会对其产生什么影响，我们照样可以成功编写并运行这样的代码。同时，Spring还提供了一些辅助类可供我们选择使用，这些辅助类简化了传统的数据库操作流程，在一定程度上节省了工作量，提高了编码效率。
对于依赖容器的参数化事务管理而言，Spring则表现出了极大的价值。Spring本身也是一个容器，只是相对EJB容器而言，Spring显得更为轻便小巧。我们无需付出其他方面的代价，即可通过Spring实现基于容器的事务管理（本质上来讲，Spring的事务管理是基于动态AOP）。
myjava_024 2008-12-01
- 打赏
- 举报
偶也贴一个
楼主看看这个，有个例子
http://www.blogjava.net/yutian727/articles/128618.html
楼主看看这个，有个例子
http://www.blogjava.net/yutian727/articles/128618.html
加载更多回复（3）
