連接池jar:c3p0
代碼結構
-----------------------------------------------
配置文件 config.properties
#hibernate.dialect=sy.util.Oracle10gDialect
#driverClassName=oracle.jdbc.driver.OracleDriver
#validationQuery=SELECT 1 FROM DUAL
#jdbc_url=jdbc:oracle:thin:@localhost:1521:orcl
#jdbc_username=bjlyjoa
#jdbc_password=bjlyjoa
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
driverClass=com.mysql.jdbc.Driver
validationQuery=SELECT 1
jdbcUrl=jdbc\:mysql\://192.168.232.88\:3306/xlzj_sh?useUnicode\=true&characterEncoding\=UTF-8&zeroDateTimeBehavior\=convertToNull
user=root
password=123456
#hibernate.dialect=org.hibernate.dialect.SQLServer2008Dialect
#driverClassName=net.sourceforge.jtds.jdbc.Driver
#validationQuery=SELECT 1
#jdbc_url=jdbc:jtds:sqlserver://127.0.0.1:1433/qx
#jdbc_username=sa
#jdbc_password=123456
hibernate.hbm2ddl.auto=none
hibernate.show_sql=false
hibernate.format_sql=false
hibernate.use_sql_comments=false
----------------------------------------------------------------------------
數據庫連接 文件
package light.mvc.framework.connectUtil;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.DataSources;
/**
*
*
* 項目名稱：s4h4s2s
* 類名稱：DataSourceConnUtil
* 類描述： c3p0連接池管理類
* 創建人：劉軍/jun liu
* 創建時間：2015-12-19 下午11:40:35
* 修改人：劉軍/shall_liu
* 修改時間：2015-12-19 下午11:40:35
* 修改備注：
* @version
*
*/
public class DataSourceConnUtil {
private static final String JDBC_DRIVER = "driverClass";
private static final String JDBC_URL = "jdbcUrl";
private static DataSource ds;
/**
* 初始化連接池代碼塊
*/
static{
initDBSource();
}
/**
* 初始化c3p0連接池
*/
private static final void initDBSource(){
Properties c3p0Pro = new Properties();
try {
//加載配置文件
c3p0Pro.load(DataSourceConnUtil.class.getResourceAsStream("/config.properties"));
//c3p0Pro.load(new FileInputStream(PathUtil.getPath("dabase.properties")));
} catch (Exception e) {
e.printStackTrace();
}
String drverClass = c3p0Pro.getProperty(JDBC_DRIVER);
if(drverClass != null){
try {
//加載驅動類
Class.forName(drverClass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Properties jdbcpropes = new Properties();
Properties c3propes = new Properties();
for(Object key:c3p0Pro.keySet()){
String skey = (String)key;
if(skey.startsWith("c3p0.")){
c3propes.put(skey, c3p0Pro.getProperty(skey));
}else{
jdbcpropes.put(skey, c3p0Pro.getProperty(skey));
}
}
try {
//建立連接池
DataSource unPooled = DataSources.unpooledDataSource(c3p0Pro.getProperty(JDBC_URL),jdbcpropes);
ds = DataSources.pooledDataSource(unPooled,c3propes);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 獲取數據庫連接對象
* @return 數據連接對象
* @throws SQLException
*/
public static synchronized Connection getConnection() {
Connection conn = null;
try {
conn = ds.getConnection();
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
conn.setAutoCommit(false);//取消 事務管理：事務提交機制
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
}
-------------------------------------------------------------------------------------------------------------
package light.mvc.framework.connectUtil;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.DataSources;
/**
*
*
* 項目名稱：s4h4s2s
* 類名稱：DataSourceConnUtil
* 類描述： c3p0連接池管理類
* 創建人：劉軍/jun liu
* 創建時間：2015-12-19 下午11:40:35
* 修改人：劉軍/shall_liu
* 修改時間：2015-12-19 下午11:40:35
* 修改備注：
* @version
*
*/
public class DataSourceConnUtil {
private static final String JDBC_DRIVER = "driverClass";
private static final String JDBC_URL = "jdbcUrl";
private static DataSource ds;
/**
* 初始化連接池代碼塊
*/
static{
initDBSource();
}
/**
* 初始化c3p0連接池
*/
private static final void initDBSource(){
Properties c3p0Pro = new Properties();
try {
//加載配置文件
c3p0Pro.load(DataSourceConnUtil.class.getResourceAsStream("/config.properties"));
//c3p0Pro.load(new FileInputStream(PathUtil.getPath("dabase.properties")));
} catch (Exception e) {
e.printStackTrace();
}
String drverClass = c3p0Pro.getProperty(JDBC_DRIVER);
if(drverClass != null){
try {
//加載驅動類
Class.forName(drverClass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Properties jdbcpropes = new Properties();
Properties c3propes = new Properties();
for(Object key:c3p0Pro.keySet()){
String skey = (String)key;
if(skey.startsWith("c3p0.")){
c3propes.put(skey, c3p0Pro.getProperty(skey));
}else{
jdbcpropes.put(skey, c3p0Pro.getProperty(skey));
}
}
try {
//建立連接池
DataSource unPooled = DataSources.unpooledDataSource(c3p0Pro.getProperty(JDBC_URL),jdbcpropes);
ds = DataSources.pooledDataSource(unPooled,c3propes);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 獲取數據庫連接對象
* @return 數據連接對象
* @throws SQLException
*/
public static synchronized Connection getConnection() {
Connection conn = null;
try {
conn = ds.getConnection();
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
conn.setAutoCommit(false);//取消 事務管理：事務提交機制
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
}
------------------------------------------------------------------------------------------------------------
package light.mvc.framework.connectUtil.jdbcUtl;
/**
*
* @Title: SqlParameter.java
* @Package light.mvc.framework.connectUtil.jdbcUtl
* @Description: TODO(存儲過程參數類型)
* @author 劉軍
* @date 2016-3-19 下午2:47:02
* @version V1.0
*/
public class SqlParameter {
/**
* 參數名稱
*/
public String Name;
/**
* 參數值
*/
public Object Value;
/**
* true表示參數為輸出類型
*/
public boolean OutPut;
/**
* 參數類型
*/
public int Type;
/**
* 輸入類型參數的構造函數
* @param name 存儲過程 輸入類型 參數名稱
* @param value 存儲過程 輸入類型 參數值
*/
public SqlParameter(String name,Object value){
this.Name = name;
this.Value= value;
}
/**
* 輸出類型參數的構造函數
* @param type 存儲過程 輸出類型 參數類型
* @param name 存儲過程 輸出類型 參數名稱
*/
public SqlParameter(int type,String name){
this.Name = name;
this.OutPut = true;
this.Type = type;
}
/**
* 返回類型參數的構造函數
* @param type 存儲過程 返回類型
*/
public SqlParameter(int type){
this.Name = "";
this.OutPut = true;
this.Type = type;
}
}
-----------------------------------------------------------------------------------------------------
package light.mvc.framework.connectUtil.jdbcUtl;
/**
*
* @Title: SqlParameter.java
* @Package light.mvc.framework.connectUtil.jdbcUtl
* @Description: TODO(存儲過程參數類型)
* @author 劉軍
* @date 2016-3-19 下午2:47:02
* @version V1.0
*/
public class SqlParameter {
/**
* 參數名稱
*/
public String Name;
/**
* 參數值
*/
public Object Value;
/**
* true表示參數為輸出類型
*/
public boolean OutPut;
/**
* 參數類型
*/
public int Type;
/**
* 輸入類型參數的構造函數
* @param name 存儲過程 輸入類型 參數名稱
* @param value 存儲過程 輸入類型 參數值
*/
public SqlParameter(String name,Object value){
this.Name = name;
this.Value= value;
}
/**
* 輸出類型參數的構造函數
* @param type 存儲過程 輸出類型 參數類型
* @param name 存儲過程 輸出類型 參數名稱
*/
public SqlParameter(int type,String name){
this.Name = name;
this.OutPut = true;
this.Type = type;
}
/**
* 返回類型參數的構造函數
* @param type 存儲過程 返回類型
*/
public SqlParameter(int type){
this.Name = "";
this.OutPut = true;
this.Type = type;
}
}
--------------------------------------------------------------------------------------------------------------------
package light.mvc.framework.connectUtil.jdbcUtl;
import java.sql.ResultSet;
/**
*
* @Title: ObjectMapper.java
* @Package light.mvc.framework.connectUtil.jdbcUtl
* @Description: TODO(用於轉換數據結果集 )
* @author 劉軍
* @date 2016-3-19 上午9:52:18
* @version V1.0
*/
public interface ObjectMapper {
public Object mapping(ResultSet rs);
}
-------------------------------------------------------------------------------------------------------
package light.mvc.framework.connectUtil.jdbcUtl;
import java.sql.ResultSet;
/**
*
* @Title: ObjectMapper.java
* @Package light.mvc.framework.connectUtil.jdbcUtl
* @Description: TODO(用於轉換數據結果集 )
* @author 劉軍
* @date 2016-3-19 上午9:52:18
* @version V1.0
*/
public interface ObjectMapper {
public Object mapping(ResultSet rs);
}
--------------------------------------------------------------------------------------------------------
package light.mvc.framework.connectUtil.jdbcUtl;
import java.sql.ResultSet;
/**
*
* @Title: ObjectMapper.java
* @Package light.mvc.framework.connectUtil.jdbcUtl
* @Description: TODO(用於轉換數據結果集 )
* @author 劉軍
* @date 2016-3-19 上午9:52:18
* @version V1.0
*/
public interface ObjectMapper {
public Object mapping(ResultSet rs);
}
--------------------------------------------------------------------------------------------------------------
package light.mvc.dao.impl;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import light.mvc.dao.JdbcBaseDao;
import light.mvc.dao.JdbcDao;
import light.mvc.framework.connectUtil.jdbcUtl.ObjectMapper;
import light.mvc.framework.connectUtil.jdbcUtl.PageModel;
import light.mvc.pageModel.demo.Demo;
import light.mvc.service.demo.impl.DemoMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class JdbcDaoImpl extends Object implements JdbcDao{
@Autowired
private JdbcBaseDaoImpl jdbcBaseUtil =new JdbcBaseDaoImpl();
public JdbcBaseDaoImpl getJdbcBaseUtil() {
return jdbcBaseUtil;
}
public void setJdbcBaseUtil(JdbcBaseDaoImpl jdbcBaseUtil) {
this.jdbcBaseUtil = jdbcBaseUtil;
}
/**
*
* @Title: insert
* @Description: TODO(插入單挑數據)
* @param @param sql 查詢sql
* @param @param obj 參數數組
* @param @param isGenerateKey (true false)
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean insert(String sql, Object[] obj){
return jdbcBaseUtil.update(sql, obj, false);
}
/**
*
* @author 劉軍
* @date 2016-3-19 下午2:23:42
* @version V1.0
* @Title: insertLines
* @Description: TODO(新增)
* @param @param sql
* @param @param obj
* @param @return 設定文件
* @return int 返回類型
* @throws
*/
public int insertLines(String sql, Object[] obj){
return jdbcBaseUtil.executeUpdate(sql, obj);
}
/**
*
* @author 劉軍
* @date 2016-3-19 下午2:05:19
* @version V1.0
* @Title: insert
* @Description: TODO(新增)
* @param @param sql
* @param @param obj
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean insertByList(String sql, List<Object> obj){
return jdbcBaseUtil.updateByPreparedStatement(sql, obj);
}
/**
*
* @Title: delete
* @Description: TODO(刪除單挑數據)
* @param @param sql 刪除sql
* @param @param obj 參數數組
* @param @param isGenerateKey (true false)
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean delete(String sql, Object[] obj){
return jdbcBaseUtil.update(sql, obj, false);
}
/**
*
* @author 劉軍
* @date 2016-3-19 下午2:19:20
* @version V1.0
* @Title: delete
* @Description: TODO(刪除單挑數據)
* @param @param sql
* @param @param obj
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean delete(String sql,List<Object> obj){
return jdbcBaseUtil.updateByPreparedStatement(sql, obj);
}
/**
*
* @Title: deleteALL
* @Description: TODO(批量刪除數據)
* @param @param sql
* @param @param obj
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean deleteALL(String sql, Object[] obj){
StringBuffer sbStr = new StringBuffer();
for (int i = 0; i < obj.length; i++) {
sbStr.append("?,");
}
String sqls =sql+"("+ sbStr.substring(0, sbStr.length() - 1) + ")";
return jdbcBaseUtil.update(sqls, obj, false);
}
/**
*
* @author 劉軍
* @date 2016-3-19 下午2:20:56
* @version V1.0
* @Title: deleteALL
* @Description: TODO(刪除 批量刪除 )
* @param @param sql
* @param @param obj
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean deleteALL(String sql,List<Object> obj){
StringBuffer sbStr = new StringBuffer();
for (int i = 0; i < obj.size(); i++) {
sbStr.append("?,");
}
String sqls =sql+"("+ sbStr.substring(0, sbStr.length() - 1) + ")";
return jdbcBaseUtil.updateByPreparedStatement(sqls, obj);
}
/**
*
* @Title: update
* @Description: TODO(更新單挑數據記錄)
* @param @param sql
* @param @param obj
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean update(String sql, Object[] obj){
return jdbcBaseUtil.update(sql, obj, false);
}
/**
*
* @author 劉軍
* @date 2016-3-19 下午2:21:45
* @version V1.0
* @Title: update
* @Description: TODO(修改 )
* @param @param sql
* @param @param obj
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean update(String sql, List<Object> obj){
return jdbcBaseUtil.updateByPreparedStatement(sql, obj);
}
/**
*
* @Title: queryFrist
* @Description: TODO(查詢出第一條數據記錄)
* @param @param tale
* @param @param objParams
* @param @return 設定文件
* @return Object 返回類型
* @throws
*/
public Object queryFrist(String tale,Object[] objParams){
String sql = "select * from "+tale+"";
Object[] obj = objParams;
return (Object) query(sql, obj, new DemoMapper()).get(0);
}
/**
*
* @author 劉軍
* @date 2016-3-19 上午9:41:06
* @version V1.0
* @Title: find
* @Description: TODO(查詢一條記錄 )
* @param @param sql
* @param @param obj
* @param @param mapper
* @param @return 設定文件
* @return Object 返回類型
* @throws
*/
public Object find(String sql, Object[] obj, ObjectMapper mapper){
return jdbcBaseUtil. find( sql, obj, mapper) ;
}
/**
*
* @Title: query
* @Description: TODO( 查詢所有的數據記錄；並以list 集合(或者：Object 對象)返回 )
* @param @param sql
* @param @param obj
* @param @param mapper
* @param @return 設定文件
* @return List<? extends Object> 返回類型
* @throws
*/
public List<? extends Object> query(String sql, Object[] obj,
ObjectMapper mapper) {
return jdbcBaseUtil.query(sql, obj, mapper);
}
/**
*
* @Title: CountNum
* @Description: TODO( select count(*)from table 的總數據條數)
* @param @param tableName (數據庫表名)
* @param @return 設定文件
* @return int 返回類型
* @throws
*/
public int CountNum (String tableName){
return jdbcBaseUtil.returnTableCount(tableName);
}
/**
*
* @Title: queryPageNumber
* @Description: TODO(分頁查詢)
* @param @param pageNo 第幾頁
* @param @param pageSize 一頁顯示多少條數據
* @param @param table 查詢哪個表
* 全表無條件查詢
* {select * from （ tablea a,tableb b where a.id=b.id）limt numStrat,numStop}
* 全表 帶條件模糊查詢：
*SELECT * FROM demo a ,demo b WHERE a.id=b.id AND a.id LIKE "1%" LIMIT 0,15;
* @param @return 設定文件
* @return PageModel 返回類型
* @throws
*/
public PageModel queryPageNumber(int pageNo, int pageSize,String table) {
int countTotal=CountNum(table);
//oracle 分頁
//String sql="select * from (select j.*,rownum rn from (select * from "+table+") j where rownum<=?) where rn>?";
//mysql 分頁
String sql="SELECT * FROM "+table+" LIMIT ?,?;";
Object[] obj = {(pageNo - 1) * pageSize, pageNo * pageSize};
List<Demo> list = (List<Demo>) query(sql, obj,new DemoMapper());
PageModel pagemodel = new PageModel();
pagemodel.setPageNo(pageNo);
pagemodel.setPageSize(pageSize);
pagemodel.setList(list);
pagemodel.setTotalRecords(countTotal);
if(pageSize!=0){
pagemodel.setCountPageNo(countTotal/pageSize);
}
return pagemodel;
}
/**
*
* @Title: findSimpleResult 獲取最后一條（單條）記錄
* @Description: TODO(查詢單條記錄)
* @param @param sql
* @param @param params
* @param @return 設定文件
* @return Map<String,Object> 返回類型
* @throws
*/
public Map<String, Object> findSimpleResult(String sql, List<Object> params){
return jdbcBaseUtil.findSimpleResult(sql, params);
}
/**
*
* @author 劉軍
* @date 2016-3-19 上午12:30:02
* @version V1.0
* @Title: findModeResult 查詢多條記錄
* @Description: TODO(查詢多條記錄)
* @param @param sql
* @param @param params
* @param @return 設定文件
* @return List<Map<String,Object>> 返回類型
* @throws
*/
public List<Map<String, Object>> findModeResult(String sql, List<Object> params){
return jdbcBaseUtil.findModeResult(sql,params);
}
/**
*
* @author 劉軍
* @date 2016-3-19 上午8:43:07
* @version V1.0
* @Title: executeQuerySingle
* @Description: TODO(SQL 查詢將查詢結果：一行一列)
* @param @param sql
* @param @param params
* @param @return 設定文件
* @return Object 返回類型
* @throws
*/
public Object executeQuerySingle(String sql, Object[] params){
return jdbcBaseUtil.executeQuerySingle(sql, params);
}
/**
*
* @author 劉軍
* @date 2016-3-19 上午9:08:05
* @version V1.0
* @Title: findSimpleRefResult
* @Description: TODO(通過反射機制查詢單條記錄)
* @param @param sql
* @param @param params
* @param @param cls
* @param @return 設定文件
* @return T 返回類型
* @throws
*/
public <T> T findSimpleRefResult(String sql, List<Object> params,Class<T> cls) {
//return JdbcBaseUtil.findSimpleRefResult(sql, params, cls);
return null;
}
/**
*
* @author 劉軍
* @date 2016-3-19 上午9:13:39
* @version V1.0
* @Title: findMoreRefResult
* @Description: TODO( 通過反射機制查詢多條記錄)
* @param @param sql
* @param @param params
* @param @param cls
* @param @return 設定文件
* @return List<T> 返回類型
* @throws
*/
public <T> List<T> findMoreRefResult(String sql, List<Object> params,
Class<T> cls) {
return jdbcBaseUtil.findMoreRefResult(sql, params, cls);
}
/**
*
* @author 劉軍
* @date 2016-3-19 上午11:03:06
* @version V1.0
* @Title: excuteQuery
* @Description: TODO(獲取結果集，並將結果放在List中)
* @param @param sql
* @param @param params
* @param @return 設定文件
* @return List<Object> 返回類型
* @throws
*/
public List<Object> excuteQuery(String sql, Object[] params){
return jdbcBaseUtil.excuteQuery( sql, params);
}
/**
*
* @author 劉軍
* @date 2016-3-19 上午11:03:03
* @version V1.0
* @Title: executeQuery
* @Description: TODO(統一的select語句，為了能夠訪問結果集，將結果集放入ArrayList，)
* @param @param sql
* @param @param parameters
* @param @return 設定文件
* @return ArrayList 返回類型
* @throws
*/
public ArrayList executeQuery(String sql, String[] parameters){
return jdbcBaseUtil.executeQuery( sql, parameters);
}
}
------------------------------------------------------------------------------------------------
package light.mvc.dao.impl;
import java.lang.reflect.Field;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Repository;
import light.mvc.dao.JdbcBaseDao;
import light.mvc.framework.connectUtil.ConnUtil;
import light.mvc.framework.connectUtil.DataSourceConnUtil;
import light.mvc.framework.connectUtil.jdbcUtl.ObjectMapper;
import light.mvc.framework.connectUtil.jdbcUtl.SqlParameter;
@Repository
public class JdbcBaseDaoImpl implements JdbcBaseDao {
/**
* 獲取連接
*/
static {
getConnection();
}
/**
* @author 劉軍
* @date 2016-3-19 上午11:14:17
* @version V1.0
* @Title: getStatement
* @Description: TODO( )
* @param @return
* @param @throws SQLException 設定文件
* @return Connection 返回類型
* @throws
*/
public Connection getStatement() throws SQLException {
Connection connection = null;
Statement statement = null;
// 僅當statement失效時才重新創建
if (statement == null || statement.isClosed() == true) {
statement = connection.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
}
return connection;
}
/**
*
* @Title: getConnection
* @Description: TODO(得到數據庫連接)
* @param @return 設定文件
* @return Connection 返回類型
* @throws
*/
public static Connection getConnection() {
Connection connection = null;
try {
/**
* 從連接池獲取連接
*/
connection = DataSourceConnUtil.getConnection();
if (connection == null) {
/**
* 直接連接數據庫
*/
connection = ConnUtil.getConn();
}
} catch (Exception e) {
e.printStackTrace();
}
return connection;
}
/**
*
* @Title: update
* @Description: TODO(更新：update)
* @param @param sql
* @param @param obj
* @param @param isGenerateKey
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean update(String sql, Object[] obj, boolean isGenerateKey) {
Connection conn = null;
PreparedStatement pstmt = null;
boolean bFlag = false;
try {
conn = JdbcBaseDaoImpl.getConnection();
pstmt = isGenerateKey ? conn.prepareStatement(sql,
Statement.RETURN_GENERATED_KEYS) : conn
.prepareStatement(sql);
for (int i = 0; i < obj.length; i++) {
pstmt.setObject(i + 1, obj[i]);
}
conn.setAutoCommit(false);//JDBC 事務管理
int i = pstmt.executeUpdate();
conn.commit();//JDBC 事務管理
if (i > 0)
bFlag = true;
} catch (SQLException ex) {
ex.printStackTrace();
try {
conn.rollback();//JDBC 事務管理
} catch (SQLException e) {
e.printStackTrace();
}
} finally {
try {
conn.close();
pstmt.close();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
return bFlag;
}
/**
*
* @Title: updateByPreparedStatement 增加、刪除、改
* @Description: TODO(增加、刪除、改)
* @param @param sql
* @param @param params
* @param @return 設定文件
* @return boolean 返回類型
* @throws
*/
public boolean updateByPreparedStatement(String sql, List<Object> params) {
boolean flag = false;
Connection connection = null;
PreparedStatement pstmt = null;
int result = -1;
try {
connection = JdbcBaseDaoImpl.getConnection();
pstmt = connection.prepareStatement(sql);
int index = 1;
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
pstmt.setObject(index++, params.get(i));
}
}
result = pstmt.executeUpdate();
connection.commit();//JDBC 事務管理
flag = result > 0 ? true : false;
} catch (SQLException e) {
try {
connection.rollback();//JDBC 事務管理
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
} finally {
try {
pstmt.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return flag;
}
/**
* insert update delete SQL語句的執行的統一方法
*
* @param sql
* SQL語句
* @param params
* 參數數組，若沒有參數則為null
* @return 受影響的行數
*/
public int executeUpdate(String sql, Object[] params) {
PreparedStatement preparedStatement = null;
// 受影響的行數
int affectedLine = 0;
Connection connection = null;
try {
// 獲得連接
connection = JdbcBaseDaoImpl.getConnection();
// 調用SQL
preparedStatement = connection.prepareStatement(sql);
// 參數賦值
if (params != null) {
for (int i = 0; i < params.length; i++) {
preparedStatement.setObject(i + 1, params[i]);
}
}
// 執行
affectedLine = preparedStatement.executeUpdate();
connection.commit();// 提交事務
} catch (SQLException e) {
System.out.println(e.getMessage());
try {
connection.rollback();//JDBC 事務管理
} catch (SQLException e1) {
e1.printStackTrace();
}
} finally {
// 釋放資源
close(connection, preparedStatement, null);
}
return affectedLine;
}
/**
*
* @Title: query
* @Description: TODO(這里用一句話描述這個方法的作用)
* @param @param sql
* @param @param obj
* @param @param mapper
* @param @return 設定文件
* @return List<? extends Object> 返回類型
* @throws
*/
public List<? extends Object> query(String sql, Object[] obj,
ObjectMapper mapper) {
Object o = null;
List<Object> list = new ArrayList<Object>();
Connection conn = null;
PreparedStatement pstmt = null;
try {
conn = JdbcBaseDaoImpl.getConnection();
pstmt = conn.prepareStatement(sql);
for (int i = 0; i < obj.length; i++) {
pstmt.setObject(i + 1, obj[i]);
}
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
o = mapper.mapping(rs);
list.add(o);
}
} catch (SQLException ex) {
ex.printStackTrace();
} finally {
try {
pstmt.close();
conn.close();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
return list;
}
/**
*
* @Title: returnTableCount
* @Description: TODO( select count(*)from table 的總數據條數)
* @param @param table
* @param @return 設定文件
* @return int 返回類型
* @throws
*/
public int returnTableCount(String table){
String sql="select count(*) as counts from "+table+"";
Connection conn = null;
ResultSet resultSet = null;
Statement pstmt = null;
int count=0;
try {
conn = JdbcBaseDaoImpl.getConnection();
pstmt = conn.createStatement();
resultSet=pstmt.executeQuery(sql);
if(resultSet.next()){
count=resultSet.getInt("counts");
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
resultSet.close();
pstmt.close();
conn.close();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
return count;
}
/**
*
* @Title: findSimpleResult 獲取最后一條（單條）記錄
* @Description: TODO(查詢單條記錄)
* @param @param sql
* @param @param params
* @param @return 設定文件
* @return Map<String,Object> 返回類型
* @throws
*/
public Map<String, Object> findSimpleResult(String sql, List<Object> params) {
Map<String, Object> map = new HashMap<String, Object>();
Connection connection = null;
PreparedStatement pstmt = null;
ResultSet resultSet = null;
int index = 1;
try {
connection = JdbcBaseDaoImpl.getConnection();
pstmt = connection.prepareStatement(sql);
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
pstmt.setObject(index++, params.get(i));
}
}
resultSet = pstmt.executeQuery();// 返回查詢結果
ResultSetMetaData metaData = resultSet.getMetaData();
int col_len = metaData.getColumnCount();
while (resultSet.next()) {
for (int i = 0; i < col_len; i++) {
String cols_name = metaData.getColumnName( i + 1);
Object cols_value = resultSet.getObject(cols_name);
if (cols_value == null) {
cols_value = "";
}
map.put(cols_name, cols_value);
}
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
resultSet.close();
pstmt.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return map;
}
/**
* 獲取結果集，並將結果放在List中
*
* @param sql
* SQL語句
* @return List 結果集
*/
public List<Object> excuteQuery(String sql, Object[] params) {
// 創建List
List<Object> list = new ArrayList<Object>();
Connection connection = null;
ResultSet rs = null;
// 創建ResultSetMetaData對象
ResultSetMetaData rsmd = null;
// 結果集列數
int columnCount = 0;
try {
// 獲得連接
connection = JdbcBaseDaoImpl.getConnection();
// 執行SQL獲得結果集
rs = executeQueryRS(sql, params);
// 將ResultSet的結果保存到List中
while (rs.next()) {
rsmd = rs.getMetaData();
// 獲得結果集列數
columnCount = rsmd.getColumnCount();
Map<String, Object> map = new HashMap<String, Object>();
for (int i = 1; i <= columnCount; i++) {
map.put(rsmd.getColumnLabel(i), rs.getObject(i));
}
list.add(map);
}
} catch (SQLException e) {
e.printStackTrace();
System.out.println(e.getMessage());
} finally {
// 關閉所有資源
try {
rs.close();
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
return list;
}
/**
* SQL 查詢將查詢結果直接放入ResultSet中
*
* @param sql
* SQL語句
* @param params
* 參數數組，若沒有參數則為null
* @return 結果集
*/
private ResultSet executeQueryRS(String sql, Object[] params) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
// 獲得連接
connection = JdbcBaseDaoImpl.getConnection();
// 調用SQL
preparedStatement = connection.prepareStatement(sql);
// 參數賦值
if (params != null) {
for (int i = 0; i < params.length; i++) {
preparedStatement.setObject(i + 1, params[i]);
}
}
// 執行
resultSet = preparedStatement.executeQuery();
} catch (SQLException e) {
System.out.println(e.getMessage());
} finally {
}
return resultSet;
}
/**
*
* @Title: findModeResult 查詢多條記錄
* @Description: TODO(查詢多條記錄)
* @param @param sql
* @param @param params
* @param @return
* @param @throws SQLException 設定文件
* @return List<Map<String,Object>> 返回類型
* @throws
*/
public List<Map<String, Object>> findModeResult(String sql,
List<Object> params) {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Connection connection = null;
PreparedStatement pstmt = null;
ResultSet resultSet = null;
int index = 1;
try {
connection = JdbcBaseDaoImpl.getConnection();
pstmt = connection.prepareStatement(sql);
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
pstmt.setObject(index++, params.get(i));
}
}
resultSet = pstmt.executeQuery();
ResultSetMetaData metaData = resultSet.getMetaData();
int cols_len = metaData.getColumnCount();
while (resultSet.next()) {
Map<String, Object> map = new HashMap<String, Object>();
for (int i = 0; i < cols_len; i++) {
String cols_name = metaData.getColumnName(i + 1);
Object cols_value = resultSet.getObject(cols_name);
if (cols_value == null) {
cols_value = "";
}
map.put(cols_name, cols_value);
}
list.add(map);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
resultSet.close();
pstmt.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return list;
}
/**
* SQL 查詢將查詢結果：一行一列
*
* @param sql
* SQL語句
* @param params
* 參數數組，若沒有參數則為null
* @return 結果集
*/
public Object executeQuerySingle(String sql, Object[] params) {
Object object = null;
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
// 獲得連接
connection = JdbcBaseDaoImpl.getConnection();
// 調用SQL
preparedStatement = connection.prepareStatement(sql);
// 參數賦值
if (params != null) {
for (int i = 0; i < params.length; i++) {
preparedStatement.setObject(i + 1, params[i]);
}
}
// 執行
resultSet = preparedStatement.executeQuery();
if (resultSet.next()) {
object = resultSet.getObject(1);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
} finally {
close(connection, preparedStatement, resultSet);
}
return object;
}
/**
*
* @Title: findSimpleRefResult 通過反射機制查詢單條記錄
* @Description: TODO(通過反射機制查詢單條記錄)
* @param @param sql
* @param @param params
* @param @param cls
* @param @return
* @param @throws Exception 設定文件
* @return T 返回類型
* @throws
*/
public <T> T findSimpleRefResult(String sql, List<Object> params,
Class<T> cls) {
T resultObject = null;
Connection connection = null;
PreparedStatement pstmt = null;
ResultSet resultSet = null;
int index = 1;
try {
connection = JdbcBaseDaoImpl.getConnection();
pstmt = connection.prepareStatement(sql);
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
pstmt.setObject(index++, params.get(i));
}
}
resultSet = pstmt.executeQuery();
ResultSetMetaData metaData = resultSet.getMetaData();
int cols_len = metaData.getColumnCount();
while (resultSet.next()) {
// 通過反射機制創建一個實例
resultObject = cls.newInstance();
for (int i = 0; i < cols_len; i++) {
String cols_name = metaData.getColumnName(i + 1);
Object cols_value = resultSet.getObject(cols_name);
if (cols_value == null) {
cols_value = "";
}
Field field = cls.getDeclaredField(cols_name);
field.setAccessible(true); // 打開javabean的訪問權限
field.set(resultObject, cols_value);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
resultSet.close();
pstmt.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return resultObject;
}
/**
* 通過反射機制查詢多條記錄
*
* @param sql
* @param params
* @param cls
* @return
* @throws Exception
*/
public <T> List<T> findMoreRefResult(String sql, List<Object> params,
Class<T> cls) {
List<T> list = new ArrayList<T>();
Connection connection = null;
PreparedStatement pstmt = null;
ResultSet resultSet = null;
int index = 1;
try {
connection = JdbcBaseDaoImpl.getConnection();
pstmt = connection.prepareStatement(sql);
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
pstmt.setObject(index++, params.get(i));
}
}
resultSet = pstmt.executeQuery();
ResultSetMetaData metaData = resultSet.getMetaData();
int cols_len = metaData.getColumnCount();
while (resultSet.next()) {
// 通過反射機制創建一個實例
T resultObject = cls.newInstance();
for (int i = 0; i < cols_len; i++) {
String cols_name = metaData.getColumnName(i + 1);
Object cols_value = resultSet.getObject(cols_name);
if (cols_value == null) {
cols_value = "";
}
Field field = cls.getDeclaredField(cols_name);
field.setAccessible(true); // 打開javabean的訪問權限
field.set(resultObject, cols_value);
}
list.add(resultObject);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
resultSet.close();
pstmt.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return list;
}
/**
*
* @Title: find
* @Description: TODO(這里用一句話描述這個方法的作用)
* @param @param sql
* @param @param obj
* @param @param mapper
* @param @return 設定文件
* @return Object 返回類型
* @throws
*/
public Object find(String sql, Object[] obj, ObjectMapper mapper) {
Object o = null;
Connection conn = null;
PreparedStatement pstmt = null;
try {
conn = JdbcBaseDaoImpl.getConnection();
pstmt = conn.prepareStatement(sql);
for (int i = 0; i < obj.length; i++) {
pstmt.setObject(i + 1, obj[i]);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
o = mapper.mapping(rs);
}
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
try {
pstmt.close();
conn.close();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
return o;
}
/**
*
* @Title: executeQuery 統一的select語句，為了能夠訪問結果集，將結果集放入ArrayList，這樣可以直接關閉資源
* @Description: TODO(統一的select語句，為了能夠訪問結果集，將結果集放入ArrayList，這樣可以直接關閉資源)
* @param @param sql
* @param @param parameters
* @param @return 設定文件
* @return ArrayList 返回類型
* @throws
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public ArrayList executeQuery(String sql, String[] parameters) {
ArrayList results = new ArrayList();
// 定義需要的變量
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 獲得連接
conn = JdbcBaseDaoImpl.getConnection();
ps = conn.prepareStatement(sql);
if (parameters != null) {
for (int i = 0; i < parameters.length; i++) {
ps.setString(i + 1, parameters[i]);
}
}
rs = ps.executeQuery();
ResultSetMetaData rsmd = rs.getMetaData();
int column = rsmd.getColumnCount();
while (rs.next()) {
Object[] objects = new Object[column];
for (int i = 1; i <= column; i++) {
objects[i - 1] = rs.getObject(i);
}
results.add(objects);
}
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
} finally {
try {
rs.close();
ps.close();
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return results;
}
/**
*
* @Title: executeQuery by statement
* @Description: TODO(執行 查詢sql 獲取結果集)
* @param @param sql
* @param @return statement resultSet
* @param @throws SQLException 設定文件
* @return ResultSet 返回類型
* @throws
*/
public ResultSet executeQuery(String sql) {
Statement statement = null;
ResultSet resultSet = null;
Connection connection = null;
try {
connection = getStatement();
if (resultSet != null && resultSet.isClosed() == false) {
resultSet.close();
}
resultSet = null;
resultSet = statement.executeQuery(sql);
} catch (Exception e) {
e.printStackTrace();
} finally {
}
return resultSet;
}
//-------------------------------------------對象化---------------
/**
* 將一條記錄轉成一個對象
*
* @param cls
* 泛型類型
* @param rs
* ResultSet對象
* @return 泛型類型對象
* @throws InstantiationException
* @throws IllegalAccessException
* @throws SQLException
*/
private static <T> T executeResultSet(Class<T> cls, ResultSet rs)
throws InstantiationException, IllegalAccessException, SQLException {
T obj = cls.newInstance();
ResultSetMetaData rsm = rs.getMetaData();
int columnCount = rsm.getColumnCount();
// Field[] fields = cls.getFields();
Field[] fields = cls.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
for (int j = 1; j <= columnCount; j++) {
String columnName = rsm.getColumnName(j);
if (fieldName.equalsIgnoreCase(columnName)) {
Object value = rs.getObject(j);
field.setAccessible(true);
field.set(obj, value);
break;
}
}
}
return obj;
}
//----------------------存儲過程調用-------------------------------------------
/**
* 存儲過程帶有一個輸出參數的方法
*
* @param sql
* 存儲過程語句
* @param params
* 參數數組
* @param outParamPos
* 輸出參數位置
* @param SqlType
* 輸出參數類型
* @return 輸出參數的值
*/
public Object executeQuery(String sql, Object[] params, int outParamPos,
int SqlType) {
Connection connection = null;
Statement statement = null;
Object object = null;
CallableStatement callableStatement = null;
try {
connection = JdbcBaseDaoImpl.getConnection();
// 調用存儲過程
callableStatement = connection.prepareCall(sql);
// 給參數賦值
if (params != null) {
for (int i = 0; i < params.length; i++) {
callableStatement.setObject(i + 1, params[i]);
}
}
// 注冊輸出參數
callableStatement.registerOutParameter(outParamPos, SqlType);
// 執行
callableStatement.execute();
// 得到輸出參數
object = callableStatement.getObject(outParamPos);
} catch (SQLException e) {
System.out.println(e.getMessage());
} finally {
// 釋放資源
closeAll(connection, null, callableStatement, null);
}
return object;
}
/**
* 執行不返回結果集的存儲過程
*
* @param sql
* 存儲過程名稱
* @param params
* 存儲過程參數
* @throws ClassNotFoundException
* @throws SQLException
*/
public void executeNonQuery(String sql, SqlParameter... params) {
Connection con = null;
CallableStatement cs = null;
try {
con = getConnection();
cs = con.prepareCall(sql);
setSqlParameter(cs, params);
cs.executeUpdate();
getSqlParameter(cs, params);
} catch (Exception e) {
e.printStackTrace();
} finally {
close3(con, cs, null);
}
}
/**
* 執行Insert語句，返回Insert成功之后標識列的值
*
* @param sql
* @return
* @throws ClassNotFoundException
* @throws SQLException
*/
public int executeIdentity(String sql) {
int identity = -1;
Connection con = null;
Statement ps = null;
ResultSet rs = null;
try {
con = getConnection();
ps = con.createStatement();
ps.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);
rs = ps.getGeneratedKeys();
if (rs.next()) {
// identity = rs.getInt("GENERATED_KEYS");
identity = rs.getInt(1);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
close3(con, ps, null);
}
return identity;
}
/**
* 執行不返回結果集的存儲過程
*
* @param sql
* 存儲過程名稱
* @param params
* 存儲過程參數
* @throws ClassNotFoundException
* @throws SQLException
*/
public void executeNonQuery1(String sql, SqlParameter... params) {
Connection con = null;
CallableStatement cs = null;
try {
con = getConnection();
cs = con.prepareCall(sql);
setSqlParameter(cs, params);
cs.executeUpdate();
getSqlParameter(cs, params);
} catch (Exception e) {
e.printStackTrace();
} finally {
close3(con, cs, null);
}
}
/**
* 執行返回聚合函數的操作
*
* @param sql
* 含有聚合函數的SQL語句
* @return 聚合函數的執行結果
* @throws SQLException
* @throws ClassNotFoundException
*/
public int executeScalar(String sql) {
int result = -1;
Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
con = getConnection();
ps = con.prepareStatement(sql);
rs = ps.executeQuery();
if (rs.next()) {
result = rs.getInt(1);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
close3(con, ps, rs);
}
return result;
}
/**
* 執行返回泛型集合的SQL語句
*
* @param cls
* 泛型類型
* @param sql
* 查詢SQL語句
* @return 泛型集合
* @throws ClassNotFoundException
* @throws SQLException
* @throws InstantiationException
* @throws IllegalAccessException
*/
public <T> List<T> executeList(Class<T> cls, String sql) {
List<T> list = new ArrayList<T>();
Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
con = getConnection();
ps = con.prepareStatement(sql);
rs = ps.executeQuery();
while (rs.next()) {
T obj = executeResultSet(cls, rs);
list.add(obj);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
close3(con, ps, rs);
}
return list;
}
/**
* 執行返回泛型集合的存儲過程
*
* @param cls
* 泛型類型
* @param sql
* 存儲過程名稱
* @param params
* 存儲過程參數
* @return 泛型集合
* @throws ClassNotFoundException
* @throws SQLException
* @throws InstantiationException
* @throws IllegalAccessException
*/
public <T> List<T> executeList(Class<T> cls, String sql,
SqlParameter... params) {
List<T> list = new ArrayList<T>();
Connection con = null;
CallableStatement cs = null;
ResultSet rs = null;
try {
con = getConnection();
cs = con.prepareCall(sql);
setSqlParameter(cs, params);
rs = cs.executeQuery();
while (rs.next()) {
T obj = executeResultSet(cls, rs);
list.add(obj);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
close3(con, cs, rs);
}
return list;
}
/**
* 執行返回泛型類型對象的SQL語句
*
* @param cls
* 泛型類型
* @param sql
* SQL語句
* @return 泛型類型對象
* @throws SQLException
* @throws ClassNotFoundException
* @throws InstantiationException
* @throws IllegalAccessException
*/
public <T> T executeEntity(Class<T> cls, String sql) {
T obj = null;
Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
con = getConnection();
ps = con.prepareStatement(sql);
rs = ps.executeQuery();
while (rs.next()) {
obj = executeResultSet(cls, rs);
break;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
close3(con, ps, rs);
}
return obj;
}
/**
* 執行返回泛型類型對象的存儲過程
*
* @param cls
* 泛型類型
* @param sql
* SQL語句
* @param params
* 存儲過程參數
* @return 泛型類型對象
* @throws SQLException
* @throws ClassNotFoundException
* @throws InstantiationException
* @throws IllegalAccessException
*/
public <T> T executeEntity(Class<T> cls, String sql,
SqlParameter... params) {
T obj = null;
Connection con = null;
CallableStatement cs = null;
ResultSet rs = null;
try {
con = getConnection();
cs = con.prepareCall(sql);
setSqlParameter(cs, params);
rs = cs.executeQuery();
while (rs.next()) {
obj = executeResultSet(cls, rs);
break;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
close3(con, cs, rs);
}
return obj;
}
/**
* 設置存儲過程參數名稱，參數值，參數方向
*
* @param cs
* @param params
* @throws SQLException
*/
private void setSqlParameter(CallableStatement cs,
SqlParameter... params) throws SQLException {
if (params != null) {
for (SqlParameter param : params) {
if (param.OutPut) {
String paramName = param.Name;
if (paramName == null || paramName.equals("")) {
cs.registerOutParameter(1, param.Type);// 設置返回類型參數
} else {
cs.registerOutParameter(paramName, param.Type);// 設置輸出類型參數
}
} else {
cs.setObject(param.Name, param.Value);// 設置輸入類型參數
}
}
}
}
/**
* 得到存儲過程參數執行結果
*
* @param cs
* @param params
* @throws SQLException
*/
private void getSqlParameter(CallableStatement cs,
SqlParameter... params) throws SQLException {
for (SqlParameter param : params) {
if (param.OutPut) {
String paramName = param.Name;
if (paramName == null || paramName.equals("")) {
param.Value = cs.getObject(1);// 返回類型參數值
} else {
param.Value = cs.getObject(paramName);// 輸出類型參數值
}
}
}
}
/**
*
* @Title: executeUpdate by statement
* @Description: TODO(更新結果集)
* @param @param sql
* @param @return
* @param @throws SQLException 設定文件
* @return int 返回類型
* @throws
*/
@SuppressWarnings("null")
public int executeUpdate(String sql) {
Statement statement = null;
Connection connection = null;
int result = 0;
try {
connection = getStatement();
result = statement.executeUpdate(sql);
connection.commit();//JDBC 事務管理
} catch (Exception e) {
e.printStackTrace();
try {
connection.rollback();//JDBC 事務管理
} catch (SQLException e1) {
e1.printStackTrace();
}
} finally {
try {
statement.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return result;
}
//-----------------------資源關閉---------------------------------------------
/**
* 關閉所有資源
*
* @param statement
*/
private void closeAll(Connection connection,
PreparedStatement preparedStatement,
CallableStatement callableStatement, ResultSet resultSet) {
// 關閉結果集對象
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
// 關閉PreparedStatement對象
if (preparedStatement != null) {
try {
preparedStatement.close();
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
// 關閉CallableStatement 對象
if (callableStatement != null) {
try {
callableStatement.close();
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
// 關閉Connection 對象
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}
/**
*
* @Title: close
* @Description: TODO(關閉所有的連接)
* @param @throws SQLException 設定文件
* @return void 返回類型
* @throws
*/
public void close(Connection connection, Statement statement,
ResultSet resultSet) {
try {
if (resultSet != null) {
resultSet.close();
resultSet = null;
}
if (statement != null) {
statement.close();
statement = null;
}
if (connection != null) {
connection.close();
connection = null;
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 關閉JDBC對象，釋放資源。
*
* @param con
* 連接對象
* @param ps
* 命令對象
* @param rs
* 結果集對象
* @throws SQLException
*/
private static void close3(Connection con, Statement ps, ResultSet rs) {
try {
rs.close();
if (rs != null) {
rs = null;
}
if (ps != null) {
ps.close();
ps = null;
}
if (con != null) {
con.close();
con = null;
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//--------------------main 方法----------------------------------------------
/**
* 測試 連接是否成功
*
* @param args
*/
public static void main(String[] args) {
getConnection();
}
}
-------------------------------------------------------------------------------------------------------------------
以下是 測試demo:
-------------------------------------------------------------------------------------------------------
package light.mvc.service.demo;
import java.util.List;
import java.util.Map;
import light.mvc.framework.connectUtil.jdbcUtl.PageModel;
import light.mvc.pageModel.demo.Demo;
public interface JdbcDemoService {
public boolean insert(Demo demo); //增
public boolean delete(String id); //單條刪除
public boolean delete(String[] Ids); //批量刪除
public boolean update(Demo demo); //修改
public List<Demo> query(); //全部查詢
public Demo queryfrist(); //單記錄查詢
public PageModel query(int pageNo, int pageSize); //分頁查詢
public PageModel queryLike(int pageNo, int pageSize);//分頁模糊查詢
public Map<String, Object> findSimpleResult(String sql, List<Object> params);
public List<Map<String, Object>> findModeResult();//獲取多條數據記錄
public List<Map<String, Object>> findModeResult1();//獲取多條數據記錄
public Object executeQuerySingle();//查詢將查詢結果：一行一列
public Demo findSimpleRefResult();//通過反射機制查詢單條記錄
public List<Demo> findMoreRefResult();//通過反射機制查詢多條記錄
public Demo find();
}
---------------------------------------------------------------------------------------------------------------
package light.mvc.service.demo.impl;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import light.mvc.dao.JdbcBaseDao;
import light.mvc.dao.JdbcDao;
import light.mvc.dao.impl.JdbcDaoImpl;
import light.mvc.framework.connectUtil.jdbcUtl.ObjectMapper;
import light.mvc.framework.connectUtil.jdbcUtl.PageModel;
import light.mvc.pageModel.demo.Demo;
import light.mvc.service.demo.JdbcDemoService;
@Service
public class JdbcDemoServiceImpl implements JdbcDemoService{
@Autowired
private JdbcDao jdbcUtil ;
@Autowired
private JdbcBaseDao jdbcBaseUtil ;
/**
* 新增數據
*/
@Override
public boolean insert(Demo demo) {
String sql = "insert into demo(id,name,description) values(?,?,?)";
Object[] obj = {demo.getId(),demo.getName(),demo.getDescription()};
return jdbcUtil.insert(sql, obj);
}
public boolean insert() {
long start=221008;
String sql = "insert into demo(id,name,description) values(?,?,?)";
List<Object> list=new ArrayList<Object>();
list.add(start);
list.add("name"+start);
list.add("description"+start);
return jdbcUtil.insertByList(sql, list);
}
public int insertLines() {
long start=221009;
String sql = "insert into demo(id,name,description) values(?,?,?)";
Object[] obj={start,"name"+start,"description"+start};
return jdbcUtil.insertLines(sql, obj);
}
/**
* 刪除數據
*/
@Override
public boolean delete(String id) {
String sql = "delete from demo where id=?";
Object[] obj = { id };
return jdbcUtil.delete(sql, obj);
}
/**
* 批量刪除數據
*/
@Override
public boolean delete(String[] Ids) {
Object[] obj = Ids;
String sql = "delete from demo where id in";
return jdbcUtil.deleteALL(sql, obj);
}
/**
* 更新單條記錄
*/
@Override
public boolean update(Demo demo) {
String sql = "update demo set name=?,description=? where id=?";
Object[] obj = {demo.getName(),demo.getDescription(),demo.getId()};
return jdbcUtil.update(sql, obj);
}
/**
* 查詢所有的數據記錄；並以list 集合返回
*/
@Override
public List<Demo> query() {
String sql = "select * from demo";
Object[] obj = {};
return (List<Demo>) jdbcUtil.query(sql, obj, new DemoMapper());
}
/**
* 查詢第一條數據
*/
@Override
public Demo queryfrist() {
String tale = "demo";
Object[] obj = {};
return (Demo) jdbcUtil.queryFrist(tale, obj);
}
/**
* 分頁傳遞參數查詢
*/
@Override
public PageModel query(int pageNo, int pageSize) {
String table = " demo a ,demo b where a.id=b.id ";
return jdbcUtil.queryPageNumber(pageNo, pageSize, table);
}
/**
* 模糊分頁查詢
*/
@Override
public PageModel queryLike(int pageNo, int pageSize) {
int test=1;
String table = " demo a ,demo b where a.id=b.id AND a.id LIKE '1%' ";
System.out.println(table);
return jdbcUtil.queryPageNumber(pageNo, pageSize, table);
}
/**
* 獲取最后一條（單條）記錄
*/
@Override
public Map<String, Object> findSimpleResult(String sql, List<Object> params) {
return jdbcUtil.findSimpleResult( sql, params);
}
/**
* 查詢多條記錄
*/
@Override
public List<Map<String, Object>> findModeResult(){
String str="";
List<Object> list=new ArrayList<Object>();
for(int i=1;i<10000;i++){
list.add(""+i+"");
int ii=4*i;
i=ii;
}
for(int j=0;j<list.size();j++){
if(j==0){
str =str.trim()+"?";
}else if(j!=0){
str =str.trim()+",?";
}
}
String sql="select * from demo where id in("+str+")";
return jdbcUtil.findModeResult(sql,list);
}
/**
* 查詢多條記錄
*/
@Override
public List<Map<String, Object>> findModeResult1(){
List<Object> list=new ArrayList<Object>();
String sql="select * from demo ";
return jdbcUtil.findModeResult(sql,list);
}
@Override
//查詢將查詢結果：一行一列
public Object executeQuerySingle(){
String sql="select * from demo where id in(?,?,?)";
Object[] params={"1","2","3"};
return jdbcUtil.executeQuerySingle(sql, params);
}
@Override
public Demo findSimpleRefResult(){
Demo demo=new Demo();
String sql="select * from demo where id = ?";
List<Object> list=new ArrayList<Object>();
list.add("1");
demo=jdbcBaseUtil.findSimpleRefResult(sql, list, Demo.class);
return demo;
}
/**
* 通過反射機制查詢多條記錄
*/
@Override
public List<Demo> findMoreRefResult() {
List<Demo> demoList=new ArrayList<Demo>();
String sql="select * from demo ";
List<Object> list=new ArrayList<Object>();
demoList=jdbcUtil.findMoreRefResult(sql, list, Demo.class);
return demoList;
}
public Demo find(){
Demo demo=new Demo();
String sql="select * from demo where id = ?";
Object[] params={"1"};
return (Demo) jdbcUtil.find(sql, params, new DemoMapper());
}
public List<Object> excuteQueryForOne(){
List<Object> list=new ArrayList<Object>();
String sql="select * from demo where id = ?";
Object[] params={"1"};
list=jdbcUtil.excuteQuery(sql, params);
return list;
}
public ArrayList executeQuery(){
ArrayList list=new ArrayList();
String sql="select * from demo ";
String[] params={};
list=jdbcUtil. executeQuery(sql, params);
return list;
}
}
----------------------------------------------------------------------------------------------------------------
package light.mvc.service.demo.impl;
import java.sql.ResultSet;
import light.mvc.framework.connectUtil.jdbcUtl.ObjectMapper;
import light.mvc.pageModel.demo.Demo;
public class DemoMapper implements ObjectMapper{
public Object mapping(ResultSet rs){
Demo d=new Demo();
try{
d.setId(Long.parseLong(rs.getString("id")));
d.setName(rs.getString("name"));
d.setDescription(rs.getString("description"));
}catch(Exception ex){
ex.printStackTrace();
}
return d;
}
}
------------------------------------------------------------------------------------------
package light.mvc.service.demo.impl;
import java.sql.ResultSet;
import light.mvc.framework.connectUtil.jdbcUtl.ObjectMapper;
import light.mvc.pageModel.demo.Demo;
public class DemoMapper implements ObjectMapper{
public Object mapping(ResultSet rs){
Demo d=new Demo();
try{
d.setId(Long.parseLong(rs.getString("id")));
d.setName(rs.getString("name"));
d.setDescription(rs.getString("description"));
}catch(Exception ex){
ex.printStackTrace();
}
return d;
}
}
---------------------------------------------------------------------------------------------
測試數據庫表：
DROP TABLE IF EXISTS `demo`;
CREATE TABLE `demo` (
`id` bigint(11) NOT NULL auto_increment,
`name` varchar(64) NOT NULL,
`description` varchar(255) default NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COMMENT='DEMO';
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");
insert into demo(name,description) values("demo","這是一個演示demo");