http://www.iteye.com/topic/11063?page=2

---mixed ORM and JDBC usage is a feature of Spring DAO

这是Rod Johnson在Spring官方上说的....以前我的理解是可以在同一个事务里
混合JDBC和ORM 编程(不考虑JTA).但我发现我错了..

比如有这样一个业务方法

void doBusiness(){
  doAction1(); 使用JdbcTemplete
  doAction2(); 使用JdoDaoSupport或HBDaoSupport
}

但这样缺是行不通的,Spring只是能拿到HB和JDBC的同一个数据源(DataSource)，却拿不到Hibernate和Jdbc的同一个底层Connection的连接
导致这2个方法将分别完成,并不能处在同一个事务,而且我运行的后还出现连接未释放的情况.(他们单独拿出来当然是正确的)...

难道rod的话的意思只是可以在不同的方法里，使jdbc和ORM拿到同一个数据源，mixed JDBC and ORM ?????郁闷中...]

===============

楼主以及二楼的朋友的论断错误倒也罢了，那种肯定的，结论性总结的态度很容易误导初学者的学习和理解。

提个小小的建议：下结论前要进行充分的考证，我们技术工作者尤其需要严谨的态度。需要用证据来说话。

jdo dao和jdbc dao能否在同一个事务里这我不太清楚。因为我没用过jdo daosupport。
但是jdbc daosupport和hibernate daosupport却能被wrap到同一个事务里。成立需要几点条件：
1、使用同一个datasource
2、事务交由hibernateTransactionManager管理
3、相关dao以及service需要使用runtime exception体系，使用spring提供的exception可以，自己封装设计的runtime exception体系也行。

与此相关的事务代码片断在HibernateTransactionManager类中。最好可以把DatasourceTransactionManager和HibernateTransactionManager对比来看。
在此贴上几个源码片断，多余的我就不解释了。相信大家一看自明。
HibernateTransactionManager#doGetTransaction

Java代码  
  1. HibernateTransactionObject txObject = new HibernateTransactionObject();;
  2. txObject.setSavepointAllowed(isNestedTransactionAllowed(););;
  3. if (TransactionSynchronizationManager.hasResource(getSessionFactory(););); {
  4. SessionHolder sessionHolder =
  5. (SessionHolder); TransactionSynchronizationManager.getResource(getSessionFactory(););;
  6. if (logger.isDebugEnabled();); {
  7. logger.debug("Found thread-bound session [" + sessionHolder.getSession(); +
  8. "] for Hibernate transaction");;
  9. }
  10. txObject.setSessionHolder(sessionHolder, false);;
  11. if (getDataSource(); != null); {
  12. ConnectionHolder conHolder = (ConnectionHolder);
  13. TransactionSynchronizationManager.getResource(getDataSource(););;
  14. txObject.setConnectionHolder(conHolder);;
  15. }
  16. }
  17. return txObject;
     HibernateTransactionObject txObject = new HibernateTransactionObject();;
txObject.setSavepointAllowed(isNestedTransactionAllowed(););;
if (TransactionSynchronizationManager.hasResource(getSessionFactory(););); {
SessionHolder sessionHolder =
(SessionHolder); TransactionSynchronizationManager.getResource(getSessionFactory(););;
if (logger.isDebugEnabled();); {
logger.debug("Found thread-bound session [" + sessionHolder.getSession(); +
"] for Hibernate transaction");;
}
txObject.setSessionHolder(sessionHolder, false);;
if (getDataSource(); != null); {
ConnectionHolder conHolder = (ConnectionHolder);
TransactionSynchronizationManager.getResource(getDataSource(););;
txObject.setConnectionHolder(conHolder);;
}
}
return txObject;

由此可以看出hibernateTransactionManager可以检测到绑定在当前线程上的connection

HibernateTransactionManager#doBegin

Java代码  
  1. Connection con = session.connection();;
  2. Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);;
  3. txObject.setPreviousIsolationLevel(previousIsolationLevel);;
  4. ...........
  5. if (getDataSource(); != null); {
  6. ConnectionHolder conHolder = new ConnectionHolder(con);;
  7. if (definition.getTimeout(); != TransactionDefinition.TIMEOUT_DEFAULT); {
  8. conHolder.setTimeoutInSeconds(definition.getTimeout(););;
  9. }
  10. if (logger.isDebugEnabled();); {
  11. logger.debug("Exposing Hibernate transaction as JDBC transaction [" +
  12. conHolder.getConnection(); + "]");;
  13. }
  14. TransactionSynchronizationManager.bindResource(getDataSource();, conHolder);;
  15. txObject.setConnectionHolder(conHolder);;
  16. }
  17. // bind the session holder to the thread
  18. if (txObject.isNewSessionHolder();); {
  19. TransactionSynchronizationManager.bindResource(getSessionFactory();, txObject.getSessionHolder(););;
  20. }
         Connection con = session.connection();;
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);;
txObject.setPreviousIsolationLevel(previousIsolationLevel);;
..............
if (getDataSource(); != null); {
ConnectionHolder conHolder = new ConnectionHolder(con);;
if (definition.getTimeout(); != TransactionDefinition.TIMEOUT_DEFAULT); {
conHolder.setTimeoutInSeconds(definition.getTimeout(););;
}
if (logger.isDebugEnabled();); {
logger.debug("Exposing Hibernate transaction as JDBC transaction [" +
conHolder.getConnection(); + "]");;
}
TransactionSynchronizationManager.bindResource(getDataSource();, conHolder);;
txObject.setConnectionHolder(conHolder);;
}
// bind the session holder to the thread
if (txObject.isNewSessionHolder();); {
TransactionSynchronizationManager.bindResource(getSessionFactory();, txObject.getSessionHolder(););;
}

由此可以看出，在真正启动一个事务时，hbTxnManager会先把connection绑定到当前线程，再绑定session到当前线程，由TransactionSynchronizationManager统一管理。并且上面提到的connection是从session中取得的，也就是说，无论是jdbc dao还是hibernate dao本质上使用的是同一个database connection

因此得出结论：HibernateTransactionManager实际上是可以同时管理由JdbcTemplate或JdbcDaoSupport实现的dao以及HibernateTemplate或HibernateDaoSupport实现的事务的。

Rod Johnson的话：

引用
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.

Juergen Hoeller的话：

引用
As Rod said, simply keep using HibernateTransactionManager, which auto-detects the DataSource used by Hibernate and seamlessly exposes Hibernate transactions as JDBC transactions for that DataSource. JDBC code that accesses the same DataSource via Spring will automatically participate in such transactions.

Note that you must specify the DataSource for Hibernate via LocalSessionFactoryBean's "dataSource" property to allow HibernateTransactionManager to auto-detect it. Alternatively, you can explicitly pass the DataSource to HibernateTransactionManager's "dataSource" property.

==================

http://forum.springsource.org/archive/index.php/t-24312.html

I am using Springs DataSourceTransactionManager and the TransactionProxyFactoryBean to provide declarative tx support over a number of service classes. Almost all methods proxied utilize the default isolation level. However, there are 3 methods that utilize SERIALIZABLE. In order to ensure that these methods utilize a new transaction their propogation behavior is set to PROPOGATION_NESTED.

Once in a blue moon I receive a "java.sql.SQLException: ORA-01453: SET TRANSACTION must be first statement of transaction" exception on our production systems when one of these serializable methods is invoked.

This exception occurs at:

org.springframework.jdbc.datasource.DataSourceUtil s.prepareConnectionForTransaction(DataSourceUtils. java:160)

when the DataSourceUtils attempts to set the isolation level.

Once this error occurs in production it occurs with great regularity - most likely as a result of pulling the same "crippled" connection out of the pool. We then have to bounce tomcat, we don't have other access to the DataSource, to stabilize the system.

We use DBCP as our connection pool. DBCP is configured to validate all connections when they are drawn from the pool. Neither the defaultAutoCommit or defaultTransactionIsolation parameters are set. So all connection should come out of the connection pool with autocommit set to true and the isolation level set to READ_COMMITTED.

The only way I think this could happen, is if a connection in the pool is set to autocommit false. When Spring requests the connection from the pool, DBCP would validate it thereby starting a JDBC transaction. When Spring then tries to set the isolation level to SERIALIZABLE the driver complains because a statement in a pre-existing JDBC tx has already been executed.

However, the DataSourceTransactionManager and the DataSourceUtils seem very particular about cleaning and resetting the connections before returning them to the pool. So no connection should ever be returned to the pool with its autoCommit set to false.

We never see this behavior in development. However, on those servers, tomcat is rarely up for more than a few hours between builds.

Can anyone think of another cause of this issue? How Spring would return a connection back to the pool without resetting its autoCommit back to true, perhaps when a checked exception is thrown?

thanks in advance,

carlos

Production is using:
Spring v1.2.1
Oracle DB v8.1.7
Oracle JDBC Driver v10.2.0.1.0
Apache DBCP v1.2.1
Tomcat v5.5.9
Sun JVM v1.5.0_05-b05
Windows Server 2003

TxManager and ProxyFactoryBean definitions:
<bean id="TransactionManager"
class="org.springframework.jdbc.datasource.DataSourceTran sactionManager">
<property name="dataSource">
<ref local="EDISDataSource" />
</property>
</bean>

<bean id="TransactionProxyTemplate"
class="org.springframework.transaction.interceptor.Transa ctionProxyFactoryBean"
abstract="true">
<property name="transactionManager">
<ref local="TransactionManager" />
</property>
<property name="transactionAttributes">
<props>
<prop key="authenticate*">PROPAGATION_REQUIRED</prop>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
<prop key="next*">PROPAGATION_NESTED,ISOLATION_SERIALIZABLE</prop>
<prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
</props>
</property>
</bean>

STACK TRACE

WARN [http-80-Processor22][11 Apr 2006 13:08:22,124] org.springframework.remoting.support.RemoteInvocat ionTraceInterceptor(RemoteInvocationTraceIntercept or.java:78) - Processing of HessianServiceExporter remote call resulted in fatal exception: gov.usitc.eof.ws.EDISWebService.getNextImageID

org.springframework.transaction.CannotCreateTransa ctionException: Could not open JDBC connection for transaction; nested exception is java.sql.SQLException: ORA-01453: SET TRANSACTION must be first statement of transaction

java.sql.SQLException: ORA-01453: SET TRANSACTION must be first statement of transaction

at oracle.jdbc.driver.DatabaseError.throwSqlException (DatabaseError.java:112)

at oracle.jdbc.driver.T4CTTIoer.processError(T4CTTIoe r.java:331)

at oracle.jdbc.driver.T4CTTIoer.processError(T4CTTIoe r.java:288)

at oracle.jdbc.driver.T4C8Oall.receive(T4C8Oall.java: 743)

at oracle.jdbc.driver.T4CStatement.doOall8(T4CStateme nt.java:207)

at oracle.jdbc.driver.T4CStatement.executeForRows(T4C Statement.java:946)

at oracle.jdbc.driver.OracleStatement.doExecuteWithTi meout(OracleStatement.java:1168)

at oracle.jdbc.driver.OracleStatement.executeInternal (OracleStatement.java:1687)

at oracle.jdbc.driver.OracleStatement.execute(OracleS tatement.java:1653)

at oracle.jdbc.driver.PhysicalConnection.setTransacti onIsolation(PhysicalConnection.java:1600)

at org.apache.commons.dbcp.DelegatingConnection.setTr ansactionIsolation(DelegatingConnection.java:277)

at org.apache.commons.dbcp.PoolingDataSource$PoolGuar dConnectionWrapper.setTransactionIsolation(Pooling DataSource.java:308)

at org.springframework.jdbc.datasource.DataSourceUtil s.prepareConnectionForTransaction(DataSourceUtils. java:160)

at org.springframework.jdbc.datasource.DataSourceTran sactionManager.doBegin(DataSourceTransactionManage r.java:178)

at org.springframework.transaction.support.AbstractPl atformTransactionManager.getTransaction(AbstractPl atformTransactionManager.java:234)

at org.springframework.transaction.interceptor.Transa ctionAspectSupport.createTransactionIfNecessary(Tr ansactionAspectSupport.java:217)

at org.springframework.transaction.interceptor.Transa ctionInterceptor.invoke(TransactionInterceptor.jav a:50)

at org.springframework.aop.framework.ReflectiveMethod Invocation.proceed(ReflectiveMethodInvocation.java :144)

at org.springframework.aop.framework.JdkDynamicAopPro xy.invoke(JdkDynamicAopProxy.java:174)

at $Proxy1.nextId(Unknown Source)

at gov.usitc.eof.ws.EDISWebServiceImpl.getNextImageID (Unknown Source)

at sun.reflect.GeneratedMethodAccessor264.invoke(Unkn own Source)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(Un known Source)

at java.lang.reflect.Method.invoke(Unknown Source)

at org.springframework.aop.support.AopUtils.invokeJoi npointUsingReflection(AopUtils.java:288)

at org.springframework.aop.framework.ReflectiveMethod Invocation.invokeJoinpoint(ReflectiveMethodInvocat ion.java:155)

at org.springframework.aop.framework.ReflectiveMethod Invocation.proceed(ReflectiveMethodInvocation.java :122)

at org.springframework.remoting.support.RemoteInvocat ionTraceInterceptor.invoke(RemoteInvocationTraceIn terceptor.java:68)

at org.springframework.aop.framework.ReflectiveMethod Invocation.proceed(ReflectiveMethodInvocation.java :144)

at org.springframework.aop.framework.JdkDynamicAopPro xy.invoke(JdkDynamicAopProxy.java:174)

at $Proxy7.getNextImageID(Unknown Source)

at sun.reflect.GeneratedMethodAccessor263.invoke(Unkn own Source)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(Un known Source)

at java.lang.reflect.Method.invoke(Unknown Source)

at com.caucho.hessian.server.HessianSkeleton.invoke(H essianSkeleton.java:188)

at org.springframework.remoting.caucho.HessianService Exporter.handleRequest(HessianServiceExporter.java :87)

at org.springframework.web.servlet.mvc.SimpleControll erHandlerAdapter.handle(SimpleControllerHandlerAda pter.java:44)

at org.springframework.web.servlet.DispatcherServlet. doDispatch(DispatcherServlet.java:684)

at org.springframework.web.servlet.DispatcherServlet. doService(DispatcherServlet.java:625)

at org.springframework.web.servlet.FrameworkServlet.s erviceWrapper(FrameworkServlet.java:386)

at org.springframework.web.servlet.FrameworkServlet.d oPost(FrameworkServlet.java:355)

at javax.servlet.http.HttpServlet.service(HttpServlet .java:709)

at javax.servlet.http.HttpServlet.service(HttpServlet .java:802)

at org.apache.catalina.core.ApplicationFilterChain.in ternalDoFilter(ApplicationFilterChain.java:252)

at org.apache.catalina.core.ApplicationFilterChain.do Filter(ApplicationFilterChain.java:173)

at org.apache.catalina.core.StandardWrapperValve.invo ke(StandardWrapperValve.java:213)

at org.apache.catalina.core.StandardContextValve.invo ke(StandardContextValve.java:178)

at org.apache.catalina.core.StandardHostValve.invoke( StandardHostValve.java:126)

at org.apache.catalina.valves.ErrorReportValve.invoke (ErrorReportValve.java:105)

at org.apache.catalina.core.StandardEngineValve.invok e(StandardEngineValve.java:107)

at org.apache.catalina.connector.CoyoteAdapter.servic e(CoyoteAdapter.java:148)

at org.apache.coyote.http11.Http11Processor.process(H ttp11Processor.java:856)

at org.apache.coyote.http11.Http11Protocol$Http11Conn ectionHandler.processConnection(Http11Protocol.jav a:744)

at org.apache.tomcat.util.net.PoolTcpEndpoint.process Socket(PoolTcpEndpoint.java:527)

at org.apache.tomcat.util.net.LeaderFollowerWorkerThr ead.runIt(LeaderFollowerWorkerThread.java:80)

at org.apache.tomcat.util.threads.ThreadPool$ControlR unnable.run(ThreadPool.java:684)

at java.lang.Thread.run(Unknown Source)

==============

http://www.blogjava.net/RongHao/archive/2007/10/09/151411.html

结合spring+hibernate与jdbc的事务

问题背景：我们是一家工作流公司，客户采购我们的产品后，将其嵌入其项目中。我们的工作流采用的是   spring+hibernate的方式，客户项目则是jdbc直接进行数据库操作。
问题：客户在其数据库操作过程中需要调用我们的工作流接口，这样就需要将我们的工作流操作与他们的业  务操作置于同一个事务中。我们的服务采用的都是spring的声明式事务，而客户采用的是对         connection进行事务处理。如何保证事务的一致性？
想到的解决方案一：使用jta事务，用tomcat+jotm提供事务管理器。为什么一开始就想到要使用jta事务？？实际上我们和客户都是使用的同一个数据库，为了方便，各自使用了不同的数据库连接方式，使用jta的话确实有bt的意思在里面。但是事实上是我们的第一反应都是jta。最后没有采用该方法的原因也很简单：我没有将jotm配置成功！汗一个。
想到的解决方案二：将客户的这些特定代码用spring管理起来。因为要修改客户部分代码，这个方案遭到了客户的强烈反对。于是放弃。
想到的解决方案三：客户数据库操作与我们的服务使用同一个数据库连接。然后编程处理事务。存在两种方式：一种是把客户的连接传给我们，另一种则是把我们的连接传给客户。第一种方式对我们的影响太大，所以最后决定采用后一种方式：从hibernate session中获取connection然后传递给客户。接下来查看一下HibernateTemplate的execute()方法，思路就很简单了：获取定义的sessionFactory-->创建一个新的session并打开-->将session与当前线程绑定-->给客户代码返回connection-->打开事务-->客户使用我们传递的connection进行数据库操作-->我们不带声明事务的服务操作-->提交事务-->解除绑定。
实际要注意的地方是：1、将session与当前线程绑定使用的TransactionSynchronizationManager.bindResource()方法，这样在HibernateTemplate里才能找到session；
                    2、我们的服务一定要把声明式事务彻底干掉，否则会有commit;
                    3、我们服务调用完毕后一定要flush session，否则客户代码不会感知数据库里的数据变化。
最终解决：使用了spring里常用的模板和回调。代码如下：

public   class  TransactionTemplate {

protected   final  Log logger  =  LogFactory.getLog(TransactionTemplate. class );

private  FlushMode flushMode  =  FlushMode.ALWAYS;

public  Object execute(TransactionCallback callback) {
         // 首先获取sessionFactory
        SessionFactory sessionFactory  =  (SessionFactory) Framework.getEngine()
                .getContainer().getComponent( " sessionFactory " );
         // 创建一个新的session并打开
        logger.debug( " Opening single Hibernate Session in TransactionTemplate " );
        Session session  =  getSession(sessionFactory);
         // 将session与当前线程绑定
        TransactionSynchronizationManager.bindResource(sessionFactory,  new  SessionHolder(session));
         // 获取数据库连接
        Connection conn  =  session.connection();
        Object result  =   null ;
        Transaction transaction  =   null ;
         try  {
             // 开始处理事务
            transaction  =  session.beginTransaction();
             try  {
                result  =  callback.doInTransaction(conn);
            }
             catch  (RuntimeException ex) {
                doRollback(session, transaction);
                 throw  ex;
            }
             catch  (Error err) {
                doRollback(session, transaction);
                 throw  err;
            }
             // 如果数据库操作过程中没有发生异常则提交事务
            transaction.commit();
        }  catch  (WorkflowException e) {
            logger.error( " 数据库操作失败，事务回滚也失败！ " );
             throw  e;
        }  catch  (RuntimeException ex) {
            logger.error( " 数据库操作失败，事务被回滚！ " );
             throw  ex;
        }  catch  (Error err) {
            logger.error( " 数据库操作失败，事务被回滚！ " );
             throw  err;
        }  finally  {
             //  将session与当前线程解除绑定
            TransactionSynchronizationManager.unbindResource(sessionFactory);
            doClose(session);
        }
         return  result;
    }

protected  Session getSession(SessionFactory sessionFactory) {
        Session session  =  SessionFactoryUtils.getSession(sessionFactory,  true );
        FlushMode flushMode  =  getFlushMode();
         if  (flushMode  !=   null ) {
            session.setFlushMode(flushMode);
        }
         return  session;
    }

private   void  doRollback(Session session, Transaction transaction) {
        logger.debug( " 数据库操作异常，开始回滚事务 " );
         try  {
            transaction.rollback();
            logger.debug( " 回滚事务成功！ " );
        }
         catch  (Exception e) {
            logger.error( " 回滚事务失败！ " );
             throw   new  WorkflowException( " 回滚事务失败！ " );
        }  finally  {
            session.clear();
        }
    }

private   void  doClose(Session session) {
        logger.debug( " 开始关闭连接 " );
         try  {
            session.close();
        }
         catch  (Exception e) {
            logger.error( " 关闭连接失败！ " );
             throw   new  WorkflowException( " 关闭连接失败！ " );
        }
    }

public  FlushMode getFlushMode() {
         return  flushMode;
    }

public   void  setFlushMode(FlushMode flushMode) {
         this .flushMode  =  flushMode;
    }
}

spring 中 Hibernate 事务和JDBC事务嵌套问题相关推荐

  1. Spring中两种编程式事务管理

    Spring中两种编程式事务管理 在代码中显示调用beginTransaction,commit,rollback等与事务处理相关的方法,这就是编程式事务管理,当只有少数事务操作时,编程式事务管理才比 ...

  2. 在Spring中使用JOTM实现JTA事务管理

    Spring 通过AOP技术可以让我们在脱离EJB的情况下享受声明式事务的丰盛大餐,脱离Java EE应用服务器使用声明式事务的道路已经畅通无阻.但是很大部分人都还认为脱离Java EE应用服务器就无 ...

  3. java jdbc开启事务_spring jdbc 事务配置

    配置WEB.XML xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="h ...

  4. mysql事务与jdbc事务_事务（mysql事务、jdbc事务）

    一.MYSQL事务 1.事务 概念:事务是一个用户定义的数据库操作序列,这些操作要么全做要么全不做,是一个不可分割的工作单位.事务可以是一条sql语句,一组sqi语句或者整个程序. 特性(ACDI): ...

  5. java jdbc事务_Java JDBC事务管理和保存点

    java jdbc事务 Transaction Management in java is required when we are dealing with relational databases ...

  6. MySQL事务（transaction）之手动控制sql事务及JDBC事务的开启

    1.概念 事务指逻辑上的一组操作,组成这组操作的各个单元,要么全部成功,要么全部不成功. 2.管理事务 2.1数据库默认的事务 数据库默认支持事务,默认的事务是:一条sql一个事务. 2.2手动控制事 ...

  7. 关于使用spring管理hibernate，能够管理事务，却不执行除查询外的增删改操作，不能让数据库数据改变的原因

    排除脏读的话 我终于学会了spring-aop管理事务,可以不写事务代码,详见我的博文 https://blog.csdn.net/thebestway/article/details/1012028 ...

  8. spring 同时配置hibernate and jdbc 事务

    http://blog.csdn.net/mypop/article/details/6120377 在项目中同时用到了JDBC和Hibernate,分别配置了各自的事务,同时配置了不同的tx:ann ...

  9. spring中的事务配置

    为什么80%的码农都做不了架构师?>>>    一 简介 spring中提供了三种事务管理的方法. 编程式事务管理 :亦即自己编写事务管理的代码,通过注入获取到spring中的事务管 ...

最新文章

  1. numpy笔记 linalg
  2. cad无法加载arx文件_多年经验总结CAD技巧8
  3. python 计时_python怎么实现计时
  4. 前端学习（1637）：前端系列实战课程之调试问题和规范
  5. 外星人台式电脑_戴尔 XPS 和外星人大更新，一边是生产力，一边是游戏
  6. aix oracle 10.2.0.1 升级 10.2.0.4,install oracle 10r2 for aix
  7. .Net Micro Framework研究—让MF支持鼠标
  8. wamp修改端口localhost
  9. mysql官网下载详细教程图文
  10. 软件项目经理应具备的素质和条件_软件项目经理的素质能力要求
  11. 将 CoAP 协议设备接入 EMQX Cloud
  12. mic in、line inline out、speaker out、headphone out　区别
  13. android沙箱,Android沙箱机制
  14. Guava学习之Map
  15. 全民农场服务器维修,微信全民农场新手常见问题集锦
  16. ROS学习总结十二：给自己的机器人添加传感器
  17. 什么是「逼格」？怎么才能提高「逼格」？
  18. linux磁盘阵列数据恢复,Linux数据恢复
  19. pyautocad相关操作案例
  20. c语言输入三个身高输出最高,输入两个人的身高,计算并输出他们的平均身高.（身高以米为单位,最后结果保留两位小数）...

热门文章

  1. 【数据结构与算法】之深入解析“格雷编码”的求解思路与算法示例
  2. 2 0 2 0 年 第 十 一 届 蓝 桥 杯 - 省赛 - CC++大学B组 - B.既约分数
  3. Django Model 自动生成 E-R 图
  4. 大数据WEB阶段Spring框架（一）IOC控制反转、DI注入依赖
  5. Java面向对象（七）包、内部类、垃圾回收机制
  6. 【Linux】一步一步学Linux——help命令(16)
  7. 【物联网】OpenWrt OpenWRT的源码下载及目录结构
  8. java 登录数据前端加密+后台验证RSA
  9. 关于计算机的使用方法中心,关于新校区行政楼和活动中心楼网络使用的说明
  10. 链接 动态链接 静态链接