package com.oa.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.oa.core.DynaForm;
import com.oa.dao.Dao;
import com.oa.jdbc.ConnectionFactory;
import com.oa.jdbc.DaoAccessException;
import com.oa.jdbc.DybaBean;
import com.oa.jdbc.JdbcPage;
import com.oa.jdbc.Page;
import com.oa.jdbc.RowsDynaClass;

/**
 * 基类DAO，实现一些基本共有方法
 * 
 * @author Gao_wx Mar 26, 2008
 */
public class BaseDao implements Dao {
	protected Log logger = LogFactory.getLog(BaseDao.class);

	// 获取数据库链接
	protected Connection getConnection() {
		return ConnectionFactory.getConnection();
	}

	// 在此链接上，根据sql语句获取List
	protected List<DybaBean> getList(Connection conn, String sql)
			throws DaoAccessException {
		try {
			Statement st = conn.createStatement(
					ResultSet.TYPE_SCROLL_INSENSITIVE,
					ResultSet.CONCUR_READ_ONLY);
			ResultSet rs = st.executeQuery(sql);
			return getList(rs);
		} catch (SQLException e) {
			throw new DaoAccessException(sql, e);
		}
	}

	// 根据Result获取List
	protected List<DybaBean> getList(ResultSet rs) throws SQLException {
		RowsDynaClass rsdc = new RowsDynaClass(rs);
		return rsdc.getRows();

	}

	// 根据sql语句获取List
	protected List<DybaBean> getList(String sql) throws DaoAccessException {
		Connection conn = getConnection();
		return getList(conn, sql);
	}

	// 在此连接上，根据sql语句，id加载一条记录
	protected DybaBean loadById(Connection conn, String sql, int id)
			throws DaoAccessException {
		try {
			PreparedStatement pst = conn.prepareStatement(sql,
					ResultSet.TYPE_SCROLL_INSENSITIVE,
					ResultSet.CONCUR_READ_ONLY);
			pst.setInt(1, id);
			ResultSet rs = pst.executeQuery();
			List list = getList(rs);
			if (list.size() > 1) {
				logger.warn("加载了2条以上的记录，请检查sql：" + sql);
			}
			if (list.size() == 0) {
				logger.warn("数据库没有此记录！");
				return null;
			} else {
				return (DybaBean) list.get(0);
			}
		} catch (SQLException e) {
			throw new DaoAccessException(sql, e);
		}
	}

	// 根据sql语句，id，加载一条记录
	protected DybaBean loadById(String sql, int id) throws DaoAccessException {
		Connection conn = getConnection();
		return loadById(conn, sql, id);
	}

	// 在此连接上，根据Sql和id删除一条记录，返回影响行数
	protected int deleteById(Connection conn, String sql, int id)
			throws SQLException {
		PreparedStatement pst = conn.prepareStatement(sql,
				ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
		pst.setInt(1, id);
		int del = pst.executeUpdate();
		return del;
	}

	// 根据sql语句，id删除一条记录
	protected int deleteById(String sql, int id) throws DaoAccessException {
		Connection conn = getConnection();
		try {
			int del = deleteById(conn, sql, id);
			return del;
		} catch (SQLException e) {
			throw new DaoAccessException(sql, e);
		}

	}

	protected Page getPage(DynaForm form, String sql) throws DaoAccessException {
		Connection conn = getConnection();
		Page page = getPage(conn, form, sql);
		return page;
	}

	// 获取分页对象
	protected Page getPage(Connection conn, DynaForm form, String sql)
			throws DaoAccessException {
		int p = form.getInt("p");
		if (p < 1) {
			p = 1;
		}
		int size = form.getInt("size");
		if (size < 10) {
			size = 10;
		}
		Page page;
		try {
			page = new JdbcPage(conn, sql, p, size);
		} catch (SQLException e) {
			throw new DaoAccessException(sql, e);
		}
		return page;
	}
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

 synchronized public void close() throws SQLException {
        if (!closed) {
            try {
                //
                // Close any open statements
                //
                ArrayList tmpList;

                synchronized (statements) {
                    tmpList = new ArrayList(statements);
                    statements.clear();
                }

                for (int i = 0; i < tmpList.size(); i++) {
                    WeakReference wr = (WeakReference)tmpList.get(i);

                    if (wr != null) {
                        Statement stmt = (Statement) wr.get();
                        if (stmt != null) {
                            try {
                                stmt.close();
                            } catch (SQLException ex) {
                                // Ignore
                            }
                        }
                    }
                }

                try {
                    // Tell the server the session is ending
                    baseTds.closeConnection();
                    // Close network connection
                    baseTds.close();
                    // Close cached TdsCore
                    if (cachedTds != null) {
                        cachedTds.close();
                        cachedTds = null;
                    }
                } catch (SQLException ex) {
                    // Ignore
                }

                socket.close();
            } catch (IOException e) {
                // Ignore
            } finally {
                closed = true;
            }
        }
    }


statement------------------------close方法

  public void close() throws SQLException {
        if (!closed) {
            SQLException closeEx = null;
            try {
                closeAllResultSets();
            } catch (SQLException ex) {
                if (!"HYT00".equals(ex.getSQLState())
                        && !"HY008".equals(ex.getSQLState())) {
                    // Only throw exceptions not caused by cancels or timeouts
                    closeEx = ex;
                }
            } finally {
                SQLException releaseEx = null;
                try {
                    if (!connection.isClosed()) {
                        connection.releaseTds(tds);
                    }
                    // Check for server side errors
                    tds.getMessages().checkErrors();
                } catch (SQLException ex) {
                    // Remember any exception thrown
                    releaseEx = ex;
                    // Queue up any result set close exceptions
                    if (closeEx != null) {
                        releaseEx.setNextException(closeEx);
                    }
                } finally {
                    // Clean up everything
                    closed = true;
                    tds = null;
                    connection.removeStatement(this);
                    connection = null;

                    // Re-throw any caught exception
                    if (releaseEx != null) {
                        throw releaseEx;
                    }
                }
            }
            // Throw any exception caught during result set close
            if (closeEx != null) {
                throw closeEx;
            }
        }
    }

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package com.jy.jdbc;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import net.sourceforge.jtds.jdbcx.JtdsDataSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class ConnectionFactory {
	private final static String USER = "";
	private final static String PWD = "";
	private final static String IP = "";
	private final static String DATABASE="";
	private final static Log logger = LogFactory.getLog(ConnectionFactory.class);
	private final static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
	private  static DataSource dst=null;
	// jtds数据源
	 static   {
		JtdsDataSource ds = new JtdsDataSource();
		ds.setServerType(1);// SQL SERVER
		ds.setServerName(IP);
		ds.setDatabaseName(DATABASE);
		ds.setPortNumber(1433);
		ds.setXaEmulation(true);
		try {
			ds.setSocketTimeout(3000);
		} catch (SQLException e1) {
			logger.error(e1);
		}
		ds.setMaxStatements(500);
		ds.setUser(USER);
		ds.setBatchSize(50);
		ds.setCacheMetaData(true);
		ds.setPassword(PWD);
		dst=ds;
	}
	 
	public static Connection getConnection() {
		Connection conn = threadLocal.get();
		if (conn == null) {
			try {
				conn = dst.getConnection();
				threadLocal.set(conn);
			} catch (SQLException e) {
				logger.error("从连接池获取连接失败！:" + e.getMessage());
			}
		}
		return conn;
	}
//dbcp连接池
//	public static DataSource getDataSource() {
//		BasicDataSource ds = new BasicDataSource();
//		ds.setDriverClassName(CLASSNAME);
//		ds.setUsername(USER);
//		ds.setPassword(PWD);
//		ds.setUrl(URL);
//		ds.setMaxActive(50);
//		ds.setMaxIdle(50);
//		ds.setMaxWait(3000); // 10 seconds
//		ds.setMaxOpenPreparedStatements(500);
//		System.out.println("NumActive: " + ds.getNumActive() + ","
//				+ "NumIdle: " + ds.getNumIdle());
//
//		return ds;
//	}

	


	// 关闭连接
	public static void closeConnection() {
		Connection conn = threadLocal.get();
		threadLocal.set(null);
		try {
			if (conn != null && !conn.isClosed()) {
				conn.close();
			}
		} catch (SQLException e) {
			logger.error("关闭连接失败！" + e.getMessage());
		}
	}


	public static void main(String[] args) {
		for (int i = 0; i < 2; i++) {
			Connection conn = getConnection();
			try {
				Statement st=conn.createStatement();
				ResultSet rs=st.executeQuery("select * from test");
				while(rs.next()){
					System.out.println(rs.getInt("id"));
				}
				closeConnection();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
	}
}

import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;

import com.jinyu.jdbc.ConnectionFactory;
public class ListenterCloseConnection implements ServletRequestListener{

	public void requestDestroyed(ServletRequestEvent arg0) {
		ConnectionFactory.closeConnection();
	}

	public void requestInitialized(ServletRequestEvent arg0) {
		
	}


}

<!-- 监听器，关闭Connection -->
<listener>
  <listener-class>
    com.tool.ListenterCloseConnection
  </listenerclass>
</listener>

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师