- 浏览: 381088 次
- 来自: www.pgp.org.cn
文章分类
最新评论
-
I_am_a_System:
尼玛的。严重鄙视!!!!!!!!!!!!!!!!!!!!!!! ...
java处理PNG图像(转载WikiMedia) -
iamaj2eeprogrammer:
你好,有问题要请教你。
发现GDCA USBKey(电子钥匙)的CSP数字签名实现存在缺陷 -
yingjinsheng:
标题和内容严重不符,麻烦你拷贝人家的东西,把标题也拷贝过来好 ...
java处理PNG图像(转载WikiMedia) -
510372845:
我还是不大明白,请问一下:我用的是tomcat,怎么样Impo ...
javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: No trusted certificate found -
chris_zcl:
你在做日记吗?不能写的详细点啊
PHP与CAS做SSO
Totodo(888669) 13:17:17
HB 和 JDBC 同一个事务?
水木-Spring(3330309) 13:17:40
jdbc也是有事务的.
水木-Spring(3330309) 13:17:54
hibernate只不过封装呢jdbc的事务而已
水木-Spring(3330309) 13:19:01
同一个数据源?
Water Ye(54422686) 13:19:56
同一个connection的话, 这样应该可以
t.beginTransaction();
a.method();
b.method();
t.commit();
Totodo(888669) 13:21:14
是滴,这个比较头疼..
Totodo(888669) 13:21:35
我们后来是传 session,然后session.getConnection.
水木-Spring(3330309) 13:22:19
如果是session.getConnection那就是同一个connection了
xxxxxxx(12345678) 13:25:24
其实我并不知道他们是怎么搞得,我觉得应该不同connection,因为只有我用了Hibernate,其他模块都没用,怎么可能同一个connection阿,头痛!
水木-Spring(3330309) 13:24:12
这个是非常麻烦的,即使使用jta都是很麻烦,因为没有spring这样的事务配置管理,jta的事务代码需要自己写.麻烦啊
Totodo(888669) 13:24:41
嘻嘻,我们现在最好的业务系统模型,,基于存储过程架构的.dao只是查查数据而已..
水木-Spring(3330309) 13:24:55
这个事前没有约定一些规则.怎么会出现这种情况?
xxxxxxx(12345678) 13:28:17
ok,假如我在HB里面用他们的connection,行不行?
水木-Spring(3330309) 13:26:16
这个说的就不专业了,大侠给说说,你怎么用他们的connection?
水木-Spring(3330309) 13:26:27
让俺学习学习.
xxxxxxx(12345678) 13:29:42
我不知道,我极少涉及到事务
Totodo(888669) 13:27:14
SessionFactroy 用的是datasource .大哥..
水木-Spring(3330309) 13:27:18
hibernate里的connection是sessionFactory产生出来的,你能用jdbc的连接,厉害.
水木-Spring(3330309) 13:27:43
跟事务是两回事啊.
xxxxxxx(12345678) 13:30:38
就是嘛,我就是这个意思
水木-Spring(3330309) 13:28:12
如果你说,jdbc用你session里产生的connection,我还觉的说的过去.
xxxxxxx(12345678) 13:30:54
我想知道怎么解决jdbc跟hb的事物
水木-Spring(3330309) 13:28:31
两种方法
xxxxxxx(12345678) 13:31:12
这是我的代码
Configuration config = new Configuration().configure();
SessionFactory sf = config.buildSessionFactory();
s = sf.openSession();
Transaction tx = s.beginTransaction();
Criteria cr = s.createCriteria(TSign.class);
xxxxxxx(12345678) 13:31:42
哦?你觉得在哪一边改动比较好?
水木-Spring(3330309) 13:29:27
哦?首先问你个问题,你的代码怎么和别人的代码交互的?
Totodo(888669) 13:30:11
好久没看到这样的代码了
Configuration ,Sf,Transaction 都能看到..
水木-Spring(3330309) 13:30:25
在你的代码里调用别人的代码?
水木-Spring(3330309) 13:31:07
准确的说,Configuration ,Sf这样的代码确实比较少见了.
水木-Spring(3330309) 13:31:25
如果不使用spring的话,Transaction是必不可少的.
xxxxxxx(12345678) 13:34:23
别人Call我的
水木-Spring(3330309) 13:31:59
话说回来,david.turing你这段代码本身就有问题的.
水木-Spring(3330309) 13:32:08
应该说效率很低的.
xxxxxxx(12345678) 13:34:48
这些代码是Workshop生成的
水木-Spring(3330309) 13:33:11
恐怖的代码生成器啊
xxxxxxx(12345678) 13:36:14
帅哥,你的思路如何,让我借鉴一下
xxxxxxx(12345678) 13:36:42
我那时候没有用JDBCTemplate,真是一个事物
xxxxxxx(12345678) 13:36:48
失误
水木-Spring(3330309) 13:34:57
no,no,即使你没用spring里的jdbcTemplate你的这段代码也大有问题的,你自己上网查查看.
水木-Spring(3330309) 13:35:03
说一下你刚才的事务的问题.
xxxxxxx(12345678) 13:38:11
恩,把问题先解决
Totodo(888669) 13:35:34
我的原则不把在tx写代码里..
不过代码都这样写,就没关系了..
带着参数互相传吧..
水木-Spring(3330309) 13:36:30
我假设你的代码(hibernate)里调用别人(jdbc),那么你可以将session里产生的connection当作参数传递给jdbc的程序.当然,事务最终在你这里做统一提交.
水木-Spring(3330309) 13:36:47
但这种情况不好的地方就是需要是同一个connection
xxxxxxx(12345678) 13:40:18
如果是别人调用我的HB呢?
水木-Spring(3330309) 13:37:41
第二种方法就是使用jta,这种情况的好处是不仅连接可以不是同一个,数据源也可以不一样.
xxxxxxx(12345678) 13:40:33
jta,复杂否?
水木-Spring(3330309) 13:38:00
如果别人调用你的,你就晕吧.
水木-Spring(3330309) 13:39:14
jta?是否复杂,两方面,首先你的的应用服务器是什么?然后你时候使用spring这样的形式来管理事务.
xxxxxxx(12345678) 13:43:35
weblogic 8.1
xxxxxxx(12345678) 13:43:44
没用用Spring
getdown(9486681) 13:41:19
现在用Spring吧...
水木-Spring(3330309) 13:41:29
呵呵,晚了.
xxxxxxx(12345678) 13:44:09
晕倒
getdown(9486681) 13:41:46
不会晚
水木-Spring(3330309) 13:41:55
应用服务器一般都实现很好的jta
getdown(9486681) 13:41:59
原来事务代码还保存没有关系..
xxxxxxx(12345678) 13:44:43
帅哥们,我是不想负这个责任
netfishx(151431) 13:42:31
对,不是说换就换的啊
xxxxxxx(12345678) 13:45:16
JTA能解决跨Connection的问题?
getdown(9486681) 13:42:38
不用换啊..
getdown(9486681) 13:42:43
JTA可以..
getdown(9486681) 13:42:48
不过JTA有点限制
getdown(9486681) 13:43:15
我有碰到代码里面直接写connection.commit()...
getdown(9486681) 13:43:22
这种情况就不能用JTA了..
水木-Spring(3330309) 13:43:36
这叫什么限制啊,呵呵.
水木-Spring(3330309) 13:43:50
这是起码的规则吧
xxxxxxx(12345678) 13:47:04
我可以改代码啊
getdown(9486681) 13:44:03
呵呵 你不知道 原有存在的很多系统都是这么控制事务的..
水木-Spring(3330309) 13:44:27
全局事务,当然不允许你自己做提交了.呵呵.
xxxxxxx(12345678) 13:47:48
tx.commit();全部更换我都可以去做
getdown(9486681) 13:44:49
最简单的还是用Spring的HibernateTransactionMananger来管理Hibernate和JDBC的事务一致.
xxxxxxx(12345678) 13:48:00
恩!
xxxxxxx(12345678) 13:48:27
但他们如果不用Spring呢? 工作量大不大?
getdown(9486681) 13:45:30
...
水木-Spring(3330309) 13:45:44
他们不用,你还做什么啊?晕
xxxxxxx(12345678) 13:49:07
我要创造条件给他们去用
getdown(9486681) 13:46:15
这是可行的
Totodo(888669) 13:46:19
老实说,我不喜欢JTA...
xxxxxxx(12345678) 13:49:23
但是要我把HB->JDBC我死活不愿意的
xxxxxxx(12345678) 13:49:42
他们也不会JDBC->HB
水木-Spring(3330309) 13:46:45
其实david.turing,你的这个改造不是很麻烦的,至少你不是跨数据源的.
xxxxxxx(12345678) 13:49:53
恩....
水木-Spring(3330309) 13:47:09
但是改造的话,风险也不小的.
xxxxxxx(12345678) 13:50:11
答案,我等不及了
getdown(9486681) 13:47:14
那就用HibernateTransactionManager来管理吧,我试过,改动最小..
getdown(9486681) 13:47:17
风险也最小..
xxxxxxx(12345678) 13:50:29
JDBC?
getdown(9486681) 13:47:30
我刚刚在一个大项目的二次开发里面用
xxxxxxx(12345678) 13:50:36
强
getdown(9486681) 13:47:52
HibernateTransactionManager可以同时保证JDBC和Hibernate的事务一致..
xxxxxxx(12345678) 13:51:47
有你这句话就行了
xxxxxxx(12345678) 13:52:00
getdown,给一个配置的sample我看看如何?
getdown(9486681) 13:48:59
呵呵 这个你放心了 我很仔细的试过了..
getdown(9486681) 13:49:07
ok
xxxxxxx(12345678) 13:52:12
thx!!!
Totodo(888669) 13:52:44
getdown(9486681) 13:44:49
最简单的还是用Spring的HibernateTransactionMananger来管理Hibernate和JDBC的事务一致.
getdown(9486681) 13:52:53
?
Totodo(888669) 13:53:02
牛了..我要学习一下.
Totodo(888669) 13:53:54
好比Spring 我有一段这样子配的..
Totodo(888669) 13:53:56
<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
<bean id="rscTransactionControl" class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="rscSessionFactory" />
</property>
</bean>
Totodo(888669) 13:54:40
对应的事务控制分别是..
<bean id="txAttributes" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
<property name="properties">
<value>
*=PROPAGATION_REQUIRED
do*=PROPAGATION_REQUIRED
< alue>
</property>
</bean>
<bean id="txInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager">
<ref bean="rscTransactionControl" />
</property>
<property name="transactionAttributeSource">
<ref bean="txAttributes" />
</property>
</bean>
Totodo(888669) 13:55:20
HB事务控制的
<bean id="autoProxyCreator" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="interceptorNames">
<value>txInterceptor< alue>
</property>
<property name="beanNames">
<list>
<value>*DAO< alue>
<value>*Manager< alue>
< st>
</property>
</bean>
Totodo(888669) 13:55:45
而我另外用个JDBC的..
Totodo(888669) 13:55:49
<bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg>
<ref bean="rscDataSource" />
</constructor-arg>
</bean>
Totodo(888669) 13:56:33
JDBC 怎么被 HibernateTransactionManager, 管理上?
getdown(9486681) 13:56:44
呵呵...
getdown(9486681) 13:56:59
我发给你看看
netfishx(151431) 13:57:12
贴出来都看看嘛
getdown(9486681) 13:57:27
ok 那我就贴出来看吧..
Totodo(888669) 13:57:28
要看哦..
getdown(9486681) 13:57:46
前面的简单 ..先
<bean id="baseService" lazy-init="true" abstract="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
getdown(9486681) 13:57:59
这个等于是总的Service的配置.
Totodo(888669) 13:58:07
er..
Totodo(888669) 13:58:09
en ..
getdown(9486681) 13:58:33
然后 JDBC的..
<bean id="userJdbcDao"
class="com.gfa4j.demo.jdbc.impl.UserJdbcDaoImpl">
<property name="dataSource">
<ref bean="dataSource" />
</property>
</bean>
getdown(9486681) 13:59:09
然后是Service的...
<bean id="userJdbcService" parent="baseService">
<property name="target">
<bean
class="com.gfa4j.demo.jdbc.impl.UserJdbcServiceImpl">
<property name="jdbcDao" ref="jdbcDao" />
</bean>
</property>
</bean>
Totodo(888669) 13:59:23
OH....
getdown(9486681) 13:59:37
这个时候其实调用JDBC的时候等于用了HibernateTransactionMananger了..
Totodo(888669) 14:00:35
这里的ref de transcationManager 就是 HibernateTransactionMananger 么?
getdown(9486681) 14:00:39
嗯..
getdown(9486681) 14:00:44
两个用的都是..
Totodo(888669) 14:00:49
天才啊..
getdown(9486681) 14:00:59
<bean id="userHibernateService" parent="baseService">
<property name="target">
<bean
class="com.gfa4j.demo.service.impl.UserHibernateServiceImpl">
<property name="userJdbcService" ref="userJdbcService" />
</bean>
</property>
</bean>
getdown(9486681) 14:01:07
这个是Hibernate Service
getdown(9486681) 14:01:14
这样就可以很方便的调用了..
netfishx(151431) 14:01:19
这样就可以???
getdown(9486681) 14:01:23
嗯 ...
Totodo(888669) 15:29:45
看了JdbcTemplate 的源..
Totodo(888669) 15:29:46
//-------------------------------------------------------------------------
// Methods dealing with static SQL (java.sql.Statement)
//-------------------------------------------------------------------------
public Object execute(StatementCallback action) throws DataAccessException {
Connection con = DataSourceUtils.getConnection(getDataSource());
Statement stmt = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null &&
this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativeStatements()) {
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
stmt = conToUse.createStatement();
DataSourceUtils.applyTransactionTimeout(stmt, getDataSource());
Statement stmtToUse = stmt;
if (this.nativeJdbcExtractor != null) {
stmtToUse = this.nativeJdbcExtractor.getNativeStatement(stmt);
}
Object result = action.doInStatement(stmtToUse);
SQLWarning warning = stmt.getWarnings();
throwExceptionOnWarningIfNotIgnoringWarnings(warning);
return result;
}
catch (SQLException ex) {
throw getExceptionTranslator().translate("executing StatementCallback", getSql(action), ex);
}
finally {
JdbcUtils.closeStatement(stmt);
DataSourceUtils.closeConnectionIfNecessary(con, getDataSource());
}
}
Totodo(888669) 15:31:42
public static Connection doGetConnection(DataSource dataSource, boolean allowSynchronization)
throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null) {
conHolder.requested();
return conHolder.getConnection();
}
logger.debug("Opening JDBC connection");
Connection con = dataSource.getConnection();
if (allowSynchronization && TransactionSynchronizationManager.isSynchronizationActive()) {
logger.debug("Registering transaction synchronization for JDBC connection");
// Use same Connection for further JDBC actions within the transaction.
// Thread-bound object will get removed by synchronization at transaction completion.
conHolder = new ConnectionHolder(con);
TransactionSynchronizationManager.bindResource(dataSource, conHolder);
TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(conHolder, dataSource));
conHolder.requested();
}
return con;
}
Totodo(888669) 15:35:37
jdbc 用的是 DataSourceTransactionManager
hb 用的是 HibernateTransactionManager
Totodo(888669) 15:39:51
It is possible--and sometimes useful--to have coordinated transactions for both. Your JDBC transactions will be managed by the HibernateTransactionManager if you work with the same JDBC DataSource in the same transaction. That is, create the SessionFactory using Spring's SessionFactoryBean using the same DataSource that your JdbcTemplates use.
The only issue to watch, of course, is that you may be invalidating your Hibernate cache by JDBC changes. Generally I find it best to use JDBC to update only tables that don't have Hibernate mappings.
It is possible--and sometimes useful--to have coordinated transactions for both. Your JDBC transactions will be managed by the HibernateTransactionManager if you work with the same JDBC DataSource in the same transaction. That is, create the SessionFactory using Spring's SessionFactoryBean using the same DataSource that your JdbcTemplates use.
The only issue to watch, of course, is that you may be invalidating your Hibernate cache by JDBC changes. Generally I find it best to use JDBC to update only tables that don't have Hibernate mappings.
Totodo(888669) 15:46:14
貌似可以啊....奇怪...
Totodo(888669) 15:47:36
sorry...骚扰了大家很久....
Totodo(888669) 15:47:42
我还是想问下..
Totodo(888669) 15:49:01
<bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg>
<ref bean="rscDataSource" />
</constructor-arg>
</bean>
<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
<bean id="rscTransactionControl" class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="rscSessionFactory" />
</property>
</bean>
<bean id="portAssignerDAO" class="bss.resourcemanager.rscass.assport.dao.impl.PortAssignerDAOImpl">
<property name="sessionFactory">
<ref bean="rscSessionFactory" />
</property>
<property name="jdbcTemplate">
<ref bean="jdbc" />
</property>
</bean>
为什么我的portAssignerDAO ,用 hb ,和jdbc 不能保证再同一个事务中呢?
Totodo(888669) 15:49:25
getDown..
Totodo(888669) 15:55:36
至少.我能证明
<bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg>
<ref bean="rscDataSource" />
</constructor-arg>
</bean>
<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
<bean id="rscTransactionControl" class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="rscSessionFactory" />
</property>
</bean>
<bean id="portAssignerDAO" class="bss.resourcemanager.rscass.assport.dao.impl.PortAssignerDAOImpl">
<property name="sessionFactory">
<ref bean="rscSessionFactory" />
</property>
<property name="jdbcTemplate">
<ref bean="jdbc" />
</property>
</bean>
这个是肯定不在一个事务里的..
Totodo(888669) 15:56:23
portAssignerDAO.updateByJdbc(xxxxxx);
portAssignerDAO.updateByHb(xxxxxx);
Totodo(888669) 15:57:30
从去年上半年开始几乎没怎么用HB了....所以关注的不多....
但是HB混用jdbctempate 记忆深刻啊...
Totodo(888669) 15:58:32
而且,我们系统在线运行的时候.websphere的日志 一支就是很多报 不在一个事务上,而且绑定不了。 ..
Totodo(888669) 15:59:36
getDown...在么?
Totodo(888669) 15:59:38
<bean id="baseService" lazy-init="true" abstract="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<bean id="userJdbcDao"
class="com.gfa4j.demo.jdbc.impl.UserJdbcDaoImpl">
<property name="dataSource">
<ref bean="dataSource" />
</property>
</bean>
<bean id="userJdbcService" parent="baseService">
<property name="target">
<bean
class="com.gfa4j.demo.jdbc.impl.UserJdbcServiceImpl">
<property name="jdbcDao" ref="userJdbcDao" />
</bean>
</property>
</bean>
<bean id="userHibernateService" parent="baseService">
<property name="target">
<bean
class="com.gfa4j.demo.service.impl.UserHibernateServiceImpl">
<property name="userJdbcService" ref="userJdbcService" />
</bean>
</property>
</bean>
Totodo(888669) 16:00:05
能否发个 UserJdbcDaoImpl 看一下..
Totodo(888669) 16:03:20
是否 UserJdbcDaoImpl 直接集成 JdbcDAOSupport?
Totodo(888669) 16:09:00
Er...
Totodo(888669) 16:09:44
千古大错啊......
Totodo(888669) 16:10:25
我误导了一波子人......
Totodo(888669) 16:10:40
非常感谢 getDown 和 水母Spring
netfishx(151431) 16:11:11
水母
无声的海浪(4485373) 16:12:28
getdown(9486681) 16:16:54
我是直接extends JdbcDAOSupport .
Totodo(888669) 16:17:12
对,继承JdbcDAOSupport
Totodo(888669) 16:17:18
我明白了.
Totodo(888669) 16:17:44
可能就是因为 我们的直接
<bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg>
<ref bean="rscDataSource" />
</constructor-arg>
</bean>
Totodo(888669) 16:18:06
我拿你的配置,简单配了一个,,的确保证在一个事务中.
getdown(9486681) 16:18:15
Totodo(888669) 16:18:50
难道直接 用JdbcTemplate 和 extentds JdbcDAOSupport 有差别..
无声的海浪(4485373) 16:19:54
没有差别
从外貌上看需要的参数都是datasource
Totodo(888669) 16:20:37
我再拿getdown 那种方式换成 我原来的试一下,结果一会儿遍知
无声的海浪(4485373) 16:21:57
那你把JdbcTemplate的参数换成JdbcTemplate
再try一下
Totodo(888669) 16:22:41
是的..我另外给dao配置了一个jdbcTempalte 属性 ,set..
水木-Spring(3330309) 16:23:17
这种方式不行?
无声的海浪(4485373) 16:23:36
和你用datasource一样吗?
无声的海浪(4485373) 16:24:26
如果一样,你原来的方式也同样可以
道理是一样的
水木-Spring(3330309) 16:25:35
刚才我就说了,getdown用的那个extends是一种方式,如果不想继承的话,可以注入嘛?
水木-Spring(3330309) 16:26:22
这种注入是没有问题的.
水木-Spring(3330309) 16:26:36
和继承是一样可行的.
无声的海浪(4485373) 16:26:45
对
Totodo(888669) 16:26:55
这个知道的拉..其实,我一开始的配置,和getDown没有本质差别...
无声的海浪(4485373) 16:27:09
刚才我说的就是水母的意思
水木-Spring(3330309) 16:27:25
总之,这两种方法都是可以的.
水木-Spring(3330309) 16:27:46
有的人不喜欢继承,觉得是强耦合,那么可以选择注入.
getdown(9486681) 16:27:49
Totodo getdown 中间不要加大写 写成getDown难看....
Totodo(888669) 16:27:52
一种已经被证实有问题了..
另外一种还没有被证实..
Totodo(888669) 16:28:05
正在证实中..
水木-Spring(3330309) 16:28:31
那种有问题?
无声的海浪(4485373) 16:28:48
... ...是不是你的写法有问题呢?
水木-Spring(3330309) 16:28:51
继承还是注入?
Totodo(888669) 16:29:11
我的这种方式.. 注入.
<bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg>
<ref bean="rscDataSource" />
</constructor-arg>
</bean>
<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
<bean id="rscTransactionControl" class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="rscSessionFactory" />
</property>
</bean>
<bean id="portAssignerDAO" class="bss.resourcemanager.rscass.assport.dao.impl.PortAssignerDAOImpl">
<property name="sessionFactory">
<ref bean="rscSessionFactory" />
</property>
<property name="jdbcTemplate">
<ref bean="jdbc" />
</property>
</bean>
Totodo(888669) 16:29:46
portAssignerDAO 是 extends HibernateDAOSupport 的..
Totodo(888669) 16:30:39
同时使用jdbc 和 saveOrUpdate就有问题呢...
水木-Spring(3330309) 16:31:06
你试试同时注入jdbcTemplate和HiberanteTemplate试试.
Totodo(888669) 16:31:34
先不玩了..晚上拿demo发给大家一起看一下,如果有兴趣的话...
反正现在对hb不感冒是了..
水木-Spring(3330309) 16:31:45
呵呵
Totodo(888669) 16:31:48
要忙了,,失陪一会儿.
无声的海浪(4485373) 16:32:07
恩
相关推荐
两个项目,一个项目是基于spring jdbc实现的分布式事务,一个是基于spring hibernate的分布式事务,hibernate项目里的applicationContext2.xml是基于mysql和mssql, applicationContext3.xml基于两个mssql, ...
总之,Spring通过其灵活的事务管理机制,极大地简化了与JDBC和Hibernate集成时的事务控制。无论是在简单还是复杂的业务逻辑中,Spring都能提供可靠的事务管理方案,确保数据的正确性和一致性。通过理解并熟练运用...
在实际项目中,Spring还允许开发者结合使用Hibernate和JDBC。例如,在大数据量的简单查询场景下,可以选择性能较高的JDBC;而在复杂的对象关系映射或者更新操作时,可以利用Hibernate的ORM优势。Spring的这种灵活性...
在Spring框架中集成和配置Hibernate事务管理是企业级Java应用中的常见实践,它能提供高效且灵活的事务处理策略。Spring作为一款强大的依赖注入(DI)和面向切面编程(AOP)容器,能够轻松地管理和协调不同数据访问...
在本教程中,我们将深入探讨如何使用Spring MVC、Spring和Hibernate三大框架进行全注解的整合开发。这个视频教程系列的第11部分,重点可能是建立在前几部分的基础之上,进一步深化对这三个核心技术的理解和实践。 ...
在`stm-ssh`和`SSHdemo`中,可能包含的是Struts2+Spring+Hibernate的整合示例。开发者通常会创建Action类来处理请求,定义Service层来封装业务逻辑,并使用Hibernate来操作数据库。Spring会管理这些对象的生命周期和...
在Spring框架中,为了管理和控制Hibernate事务,Spring提供了两种关键工具:HibernateTemplate和JdbcTemplate。这两个模板类简化了与数据库的交互,同时也处理了事务管理。让我们深入了解一下这两个类以及它们如何...
本主题将深入探讨Hibernate的编程式事务管理和Spring AOP的声明式事务管理,以及两者如何在实际项目中集成使用。 **Hibernate编程式事务管理** Hibernate作为流行的ORM(对象关系映射)框架,提供了对JDBC事务的...
它支持JDBC,并可以与Spring整合,实现事务管理和数据源配置。 JDBC(Java Database Connectivity)是Java标准的数据库连接接口,允许开发者直接操作数据库。在Hibernate等ORM框架下,JDBC作为底层支持,用于执行...
Hibernate支持JDBC事务和JTA(Java Transaction API)事务,可以与Spring的事务管理机制集成,实现统一的事务策略。 在SSH事务配置中,提到的“通用性”是指通过合理配置,可以将事务管理应用到多个DAO(数据访问...
在IT行业中,Spring框架是Java企业级应用开发的首选,其强大的依赖注入(IOC)和面向切面编程(AOP)功能使得复杂的应用管理变得轻松。而Hibernate作为一款优秀的对象关系映射(ORM)框架,简化了数据库操作。将...
在Java开发中,Spring框架和Hibernate ORM工具是两个非常重要的组件。Spring提供了强大的依赖注入(DI)和面向切面编程(AOP),而Hibernate则是一个优秀的对象关系映射(ORM)解决方案,使得开发者可以方便地操作...
在IT行业中,数据库事务是确保数据一致性的重要机制,特别是在分布式系统和多层架构中,如Spring、Hibernate和MySQL的组合。本实例将深入探讨如何在这样的环境中实现事务管理。 Spring框架以其强大的依赖注入和AOP...
- 在DAO层,使用Hibernate的Session和Query对象进行数据库操作,Spring会在事务的上下文中管理这些操作。 4. **测试**: - 编写测试用例,模拟正常情况和异常情况,确保事务管理能够正确地进行提交和回滚。 这个...
5. **事务管理**: Spring提供了声明式事务管理,可以在配置文件中定义事务管理器,并在需要事务控制的方法上添加`@Transactional`注解。这样,Spring会自动处理事务的开始、提交或回滚。 6. **测试和运行**: 最后,...
- **执行SQL操作**:在此阶段,开发者会执行一系列的SQL语句,这些语句会被包含在一个事务中。 - **提交或回滚**:如果所有操作都成功,调用`commit()`方法提交事务;若有任何错误,调用`rollback()`方法回滚事务,...
Hibernate允许开发者用Java对象来表示数据库中的记录,通过透明地管理对象状态和数据库事务,减少了直接操作SQL的复杂性。它支持各种数据库,包括MySQL、Oracle、PostgreSQL等,具有强大的查询能力,可以使用HQL...
3. 整合 Spring 和 Hibernate:在 Spring 配置文件中声明 Hibernate 的 SessionFactory Bean,并使用 Spring 的事务管理器来控制事务。 4. 实体类和数据库表映射:使用 Hibernate 的注解或 XML 映射文件,将 Java 类...
Struts2.16、Spring2.5.6、Hibernate3.2以及sqljdbc4是四个在Java开发中广泛使用的开源框架和数据库驱动,它们在构建企业级Web应用程序时起着至关重要的作用。 Struts2.16是MVC(模型-视图-控制器)设计模式的一个...
在实际使用中,Spring JDBC通常与Spring的其他模块结合,如Spring ORM(Object-Relational Mapping)和Spring AOP(Aspect-Oriented Programming),以提供更完整的数据访问解决方案。例如,Hibernate或MyBatis可以...