statement,resultset属于弱refrence，即如果statement关掉，resultset就会被自动释构,弱 refrence的做法不保险，所以JDBC3.0开始明确规定了如果connection被关，所有statement都应该关,不过这取决于使用的数 据库驱动。
应该DBMS 执行操作后，显式的关闭statement ，因为在connection关闭前，JDBC statement仍旧处于打开状态，当返回resultset后，关闭statement是必要的，尤其在遇到异常的时候。
如果不使用connection pool可以直接关闭connection，不考虑statement的关闭，使用连接池的时候，务必关闭statement，否则你的连接马上被用光，使用statement pooling除外。

http://www.w3china.org/blog/more.asp?name=hongrui&id=10283

2,Software caused connection abort: socket write error

最终找到了原因:sql写错了，写成了where name='?'

有人说原因:
oracle数据库连接与连接池之间冲突导至.
oracle database把空闲一段时间的连接关闭了，而应用服务器连接池却认为该边接还是可用的，再次访问时还是使用该连接，导致出现连接异常。
方法,当然是改数据库配置了.

spring对oracle的clob和StoredProcedure 的处理

经过几天的夜战，终于知道使用spring对oracle的存储过程操作，程序死掉的真正原因，一旦执行存储过程没有任何返回值，因为 “Statement.getUpdateCount() returns 1 instead of -1”，是oracle的驱动的bug，10.1.0.2的驱动就不行，听说10.1.0.3就没有问题，但是10.1.0.3的jdbc驱动不能下载。大家可以使用weblogic8.1SP3带的10.1.0.2或weblogic9beta的10.1.0.2，可以解决这个问题。不知道开发 oracle jdbc的程序员是什末人，没毕业的大学生，还是拖欠了工资的程序员，开发水平远不如开源数据库的jdbc驱动的人呢，再次建议oracle驱动最好是自己命名，把文件名加上版本信息，要不会死人的。

http://72.5.124.102/thread.jspa?messageID=1424984

http://group.gimoo.net/review/44109

http://azi.javaeye.com/blog/182146

http://hi.baidu.com/happyidea/blog/item/c84b313de75add0abba16779.html

3,Random Connection Closed Exceptions

These can occur when one request gets a db connection from the connection pool and closes it twice.

见http://tomcat.apache.org/tomcat-4.1-doc/jndi-datasource-examples-howto.html

       String sql="select s_id as sid,s_name as sname,s_sex as ssex,s_brith as sbrith from stu";

       List list=this.getJdbcTemplate().query(sql,new BeanPropertyRowMapper(Stu.class));

       return list;

    }

关于execute和update方法之间的区别，update方法返回的是受影响的记录数目的 一个计数，并且如果传入参数的话，使用的是java.sql.PreparedStatement,而execute方法总是使用 java.sql.Statement,不接受参数，而且他不返回受影响记录的计数，更适合于创建和丢弃表的语句，而update方法更适合于插入，更新 和删除操作，这也是我们在使用时需要注意的。

Connection conn=DataSourceUtils.getConnection(getJdbcTempldate().getDataSource());

conn=getJdbcTemplate().getNativeJdbcExtractor().getNativeConnection(conn);

OracleConnection oconn=(OracleConnection)conn;

通过DataSourceUtils获取当前线程绑定的数据连接，为了使用线程上下文相关的事务，这样写是正确的写法，如果直接从DataSource获取连接，得到的是和当前线程上下文无关的新的数据库连接实例。

http://www.javaeye.com/topic/49932?page=2

http://www.javaeye.com/problems/15846

http://www.javaeye.com/topic/87034

http://www.javaeye.com/topic/508799

http://ttitfly.javaeye.com/blog/151560

jdbcTemplate的方式里如果带上int[] argTypes显示指定每个占位符所对应的字段数据类型，可以保证类型安全，当参数值为null时，提供了更好的支持。

-----------------------

上面这句话如何理解？

后在http://javazoo.bokee.com/viewdiary.15850865.html找到原因了

今天在调试程序的时候,在后台业务逻辑类中利用JdbcTemplate进行数据同步操作时,发现当
执行jdbcTemplate.update(带?的SQL语句,new Object[]{tmp.getName( ),tmp.getNo( ),tmp.getSpeciality( ),tmp.getMounterofficer( ),tmp.getDesigner( ),tmp.getProductivity( ),tmp.getState( ))
这种操作时,如果后面参数中有值为null时,后台会报异常,细想下也是,如果是null,那就要执行jdbc的setNull(Spring底层还是用JDBC做的)方法了,但是setNull方法要知道具体的数据库字段的类型.如setNull(1,Types.VARCHAR).而在上面的方法没有体现.
终于体会到update方法中第三个参数new int[]的作用了.!
spring还是很伟大的.

如果字段名和属性名是严格对应的，那么就可以不用自己写RowMapper了，使用BeanPropertyRowMapper:

getJdbcTemplate().query(sql, new BeanPropertyRowMapper(User.class));  

类的属性字段名称要数据库中的字段名称一样或者数据库字段名为s_id类的名称为SId,
如果你没有遵守这个规范则可以在select语句后面给数据库字段名取别名

//绑定参数时，日期类型的写法,未经过验证

    public void updStu(Stu stu) {
String sql = "update stu set s_name=?,s_sex=?,s_brith=? where s_id=?";
Object[] obj = new Object[] { stu.getSname(), stu.getSsex(),new java.sql.Date(stu.getSbrith().getTime()), stu.getSid() };
      getJdbcTemplate().update(sql, obj, new int[] { Types.VARCHAR, Types.VARCHAR,Types.DATE, Types.INTEGER });
    }

ConnectionCallback的用法，使用完要手动关闭连接吗？

spring的AbstractRoutingDataSource，可以多态切换数据库?

事务抽象层http://blog.csdn.net/congqian1120/archive/2008/01/16/2046311.aspx

有 Spring 的支持，使用 JDBC 变得如此简单，我们不会再因为它的复杂性而将其的优先级打个折扣。可是，如果我们选择使用某个特定的 ORM 工具，那么我们就很难用基于 JDBC 的 DAO 实现进行替换了——目前我们就是这样。当我们同时在一个类中包含了 JDBC 和 hibernate 代码时，我们就无法使用 Spring 提供的支持。因为我们的 DAO 只能扩展 HibernateDaoSupport 或 JdbcDaoSupport 二者之一。幸运的是，这里有一个优雅的解决方案，它允许我们将 Hibernate 和 JDBC 代码封装在同一个类之内，而不会因此失去 Spring 的支持。这个方案的关键在于将 JDBC 代码封装在内部类中，之后将主体 DAO 的调用委托给这个内部类去完成。代码清单 11-6 提供了一个示例：

代码清单 11-16. 在一个单独的 DAO 中混合使用 Hibernate 和 JDBC

package com.apress.prospring.ch11.canonicalization;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

import org.springframework.orm.hibernate.support.HibernateDaoSupport;

public class MyDao extends HibernateDaoSupport {

   private MyJdbcDao innerDao;

   public MyDao() {

      innerDao = new MyJdbcDao();

   }

   public void update(MyDomainObject obj) {

      // use Hibernate to persist the data

   }

   public MyDomainObject getById(int someId) {

      return innerDao.getBy(someId);

   }

   private static class MyJdbcDao extends JdbcDaoSupport {

      public MyDomainObject getBy(int someId) {

         // do some real processing

         return null;

      }

   }

}

尽管这只是一个简单的实现，我们也可以从中得到启发。所有的 JDBC 相关代码都被转移到一个内部类中，而此内部类扩展了 JdbcDaoSupport , 所有的 Hibernate 相关功能都留在外部，外部类仍然是 HibernateDaoSupport . 的子类。通过这个类，我们可以使用 Hibernate 完成域对象的持久化，但是我们可以将查询功能交给嵌入的 JDBC DAO 去完成。

在我们的应用中有效利用标准化 ，可以通过避免大量无谓对象的创建，从而极大提升内存使用效率。如果我们必须更新标准化对象相关的数据，同时我们在 DAO 中使用了 ORM 框架，那么我们就可以以 ORM 无关的形式引入一些 JDBC 代码来加入标准化 支持。

来源:Pro Spring中文版 http://book.csdn.net/bookfiles/48/100481407.shtml

http://hi.baidu.com/%D3%F4%C3%C6%BB%A8%C9%FA%BD%B4/blog/item/7768d41e8c06ceffe0fe0ba6.html

public interface ConnectionCallback

Generic callback interface for code that operates on a JDBC Connection. Allows to execute any number of operations on a single Connection, using any type and number of Statements.

This is particularly useful for delegating to existing data access code that expects a Connection to work on and throws SQLException. For newly written code, it is strongly recommended to use JdbcTemplate's more specific operations, for example a query or updat variant.

doInConnection

ObjectdoInConnection(Connection con)
                      throws SQLException,
DataAccessException

Gets called by JdbcTemplate.execute with an active JDBC Connection. Does not need to care about activating or closing the Connection, or handling transactions.

If called without a thread-bound JDBC transaction (initiated by DataSourceTransactionManager), the code will simply get executed on the JDBC connection with its transactional semantics. If JdbcTemplate is configured to use a JTA-aware DataSource, the JDBC Connection and thus the callback code will be transactional if a JTA transaction is active.

Allows for returning a result object created within the callback, i.e. a domain object or a collection of domain objects. Note that there's special support for single step actions: see JdbcTemplate.queryForObject etc. A thrown RuntimeException is treated as application exception: it gets propagated to the caller of the template.

Parameters:

con - active JDBC Connection

Returns:

a result object, or null if none

Throws:

SQLException - if thrown by a JDBC method, to be auto-converted to a DataAccessException by a SQLExceptionTranslator

DataAccessException - in case of custom exceptions

See Also:

JdbcTemplate.queryForObject(String, Class), JdbcTemplate.queryForRowSet(String)

         在 Web 项目中，离线并发显得尤其严重。例如，用户 A 和用户 B 同时修改数据库中的某张表的 R 行，加入 R 行有两个字段分别是 C1 ， C2 。

         假如按照如下过程修改：

         1 用户 A 将数据 R （ C1,C2 ）读取到 A 的浏览器中。

         2 用户 B 将数据 R （ C1,C2 ）读取到 B 的浏览器中。

         3 用户 A 在浏览器上将数据修改为 R （ C1’ ， C2 ），同时更新到数据库。

         4 用户 B 在浏览器上将数据修改为 R （ C1 ， C2’ ），同时更新到数据库。

         上述过程存在两个问题，第一，第 4 步 B 在修改数据的时候数据库中的数据和 B 的浏览器中数据已经不一致了；第二，如果程序按照哪个字段变化在数据库中更新哪个字段的方式处理的话，那么经过上述四步修改，数据库中 R 行的内容是（ C1’,C2’ ），这和 A 或者 B 的想法都不同（ A 认为是（ C1’ ， C2 ）， B 认为是（ C1 ， C2’ ））。

         上述过程中 A 对数据库的修改过程或者 B 对数据库的修改过程，都是无法根据数据库的最新内容做修改，所以成为离线。 A 和 B 同时对记录 R 进行就该叫离线。

         以上的环境叫离线并发。

         那么如何解决离线并发过程中遇到的问题呢？我们引入锁机制。

锁机制

         锁机制，就是在需要修改的数据上加互斥锁，通过互斥锁避免数据被同时修改。锁机制更具其应用环境又分为乐观锁和悲观锁

         乐观锁

乐观锁，指认为冲突很少发生，所以只是在数据修改的时候比较修改的基础数据和数据库中的数据是否相同，相同则修改，否则提示用户重新装入数据库中已经变化的数据。

实现方法 1 ：在进行 update 的时候使用 where 条件，在 Where 标间中比较所有上一步中查询得到的数据。如果数据库中的数据没有变化，则 update 可以更新到内容，否则 update 语句不能更新到内容，可以根据 update 的返回值确定更新是否成功。

实现方法 2 ：在每一个表中追加一个特殊字段，类型为 timestamp ，每次更新的时候比较这个字段的值是否一致，如果一致，则更新，同时将这个字段更新为当前时间，否则，说明数据已经变更。这也可以使用 update 加上 where 实现。

         悲观锁

悲观锁指，需要修改的数据，在读取的时候就对数据加锁，其他用户在准备修改，读取数据的阶段判断数据是否上锁，以此来决定是否进行修改前的读操作。

                  实现方法：

                   通常在数据库中建立一张 lock 表，该表的字段包括，表明，唯一索引，时间，用户信息等。

在用户读取数据准备修改的时候，首先判断 lock 表中是否存在自己将要读取的数据。

如果不存在，则在 lock 表中添加一条记录，记录对那张表的哪行数据进行修改；如果存在，在判断时间字段是否超时。

如果超时，则更新 lock 表中本条记录的时间字段。（防止死锁的必要手段）

如果存在，也不超时，说明本条记录正在被其他用户修改，则返回并发信息。

出处:http://blog.csdn.net/struts2/archive/2007/08/14/1742686.aspx