1.DbConnection类
package com.coffee.databaseservices.database.DBConnection;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import com.coffee.bean.db.accounts.modelObjectVo;
//import org.apache.log4j.Logger;
public class DbConnection{
// Logger log = Logger.getLogger("log4j");
private Connection dbConnection = null;
private Statement selectPro = null; //用于 select 操作
private Statement updatePro = null; //用于 update 操作
private ResultSet dbResultSet = null; //操作 select 结果集
private PreparedStatement pstmt=null;
private String driverName;//声明MySql驱动类
private String dbHost;
private String dbPort;
private String dbName;
private String dbUserName;
private String dbPassword;
private String enCoding;
private String url;
//private Connection dbResultSet;
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public Connection getDbConnection() {
return dbConnection;
}
public void setDbConnection(Connection dbConnection) {
this.dbConnection = dbConnection;
}
/** *//**
* 实例化DbConnection对象
* @param host 数据库主机（IP）
* @param port 数据库端口
* @param dName 数据库名称
* @param uName 用户名
* @param password 用户密码
*
*
*/
public DbConnection(String host, String port, String dName, String uName, String password){
driverName = "com.mysql.jdbc.Driver";
dbHost = host;
dbPort = port;
dbName = dName;
dbUserName = uName;
dbPassword = password;
enCoding = "?useUnicode=true&characterEncoding=utf-8&autoReconnect=true";
}//end DbConnection( )
/** *//**
* 实例化DbConnection对象
* @param host 数据库主机（IP）
* @param port 数据库端口
* @param dName 数据库名称
* @param uName 用户名
* @param password 用户密码
*/
public DbConnection(){
Properties prop=new Properties();
InputStream in=this.getClass().getResourceAsStream("/db_sysconfig.properties");
if(in==null){
in = ClassLoader.getSystemResourceAsStream("/db_sysconfig.properties");
}
try {
prop.load(in);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// dbHost=prop.getProperty("ADBIP");
//
// dbPort=prop.getProperty("ADBPort");
//
// dbName=prop.getProperty("ADBName");
//
// dbUserName =prop.getProperty("ADBUserName");
//
// dbPassword=prop.getProperty("ADBPassword");
dbHost=prop.getProperty("SDBIP");
dbPort=prop.getProperty("SDBPort");
dbName=prop.getProperty("SDBName");
dbUserName =prop.getProperty("SDBUserName");
dbPassword=prop.getProperty("SDBPassword");
driverName = "com.mysql.jdbc.Driver";
enCoding = "?useUnicode=true&characterEncoding=utf-8&autoReconnect=true&allowMultiQueries=true";
}
/** *//**
* 连接数据库
* @return 连接成功返回true，连接失败返回false
*/
public boolean dbConnectionSuccess(){
boolean flag=false;
//Connection dbConnection = null;
StringBuilder urlTem = new StringBuilder();
urlTem.append("jdbc:mysql://");
urlTem.append(dbHost);
urlTem.append(":");
urlTem.append(dbPort);
urlTem.append("/");
urlTem.append(dbName);
urlTem.append(enCoding);
String url = urlTem.toString();
try
{
Class.forName(driverName).newInstance();
dbConnection = DriverManager.getConnection(url, dbUserName, dbPassword);
this.setDbConnection(dbConnection);
this.setUrl(url);
return true;
}catch(Exception e) {
System.err.println("数据库联接失败！");
System.out.println("url = " + url);
e.printStackTrace(); //得到详细的出错消息
// log.error(e.getMessage(),e);;
// log.error(e.getMessage(),e);
return false;
}
}// end dbConnection()
/**
* 关闭数据库连接
* @return 成功返回true， 失败返回false
*/
public boolean closeDatabase(){
try{
if(dbConnection != null)
dbConnection.close();
return true;
}catch (Exception ex){
ex.printStackTrace();
// log.info(getTrace(ex));
return false;
}
}
/**
* 执行 查询，返回一个 list 集合 适合去掉不想要的字段
* 执行专门的select操作，注意：在selectSql中的字段和fields中的个数、名称要保持一致
* @param selectSql 用于执行的select语句
* @param fields 要选择的字段
* @return 含有Map的ArrayList，一条记录形成一个Map
*/
public ArrayList queryForList(String selectSql, ArrayList fields)
{
ArrayList<Map> selectResult = new ArrayList<Map>();
Map<String, String> recordInfo;
try {
selectPro = dbConnection.createStatement();//定义Statement对象
System.out.println("JDBC 查询： " + selectSql);
dbResultSet = selectPro.executeQuery(selectSql);
while(dbResultSet.next()) {
recordInfo = new HashMap<String, String>();
for(int i = 0; i<fields.size(); ++i)
recordInfo.put((String)fields.get(i), dbResultSet.getString((String)fields.get(i)));
selectResult.add(recordInfo);
}
dbResultSet.close(); //断开结果集
selectPro.close(); //断开Statement对象
}catch(Exception e) {
System.out.println("查询失败Sql语句 " + selectSql);
e.printStackTrace();
// log.error(e.getMessage(),e);;
}finally{
this.closeDatabase();
}
return selectResult;
}
/**
* 执行 查询，返回一个 list 集合
* 执行专门的select操作，将 select 查询语句后的字段自动 封装在一个Map（适合多表查询）
* @param selectSql 用于执行的select语句
* @param
* @return 含有Map的ArrayList，一条记录形成一个Map
*/
@SuppressWarnings("static-access")
public ArrayList queryForList(String selectSql)
{
ArrayList<Map> selectResult = new ArrayList<Map>();
Map<String, String> recordInfo;
try {
selectPro = dbConnection.createStatement();//定义Statement对象
System.out.println("JDBC 查询： " + selectSql);
dbResultSet = selectPro.executeQuery(selectSql);
String[] colNames = new ORMClassSql().getColNames(dbResultSet);//得到select后的字段,多表也可以
int len=colNames.length;
while(dbResultSet.next()) {
recordInfo = new HashMap<String, String>();
for(int i = 0; i<len; ++i)
recordInfo.put((String)colNames[i], dbResultSet.getString((String)colNames[i]));
selectResult.add(recordInfo);
}
dbResultSet.close(); //断开结果集
selectPro.close(); //断开Statement对象
}catch(Exception e) {
System.out.println("选择操作失败");
System.out.println("失败Sql = " + selectSql);
e.printStackTrace();
// log.error(e.getMessage(),e);;
}finally{
this.closeDatabase();
}
return selectResult;
}
/**
* 执行 查询，返回一个 count数目
* 查询页数 分页总数目
* @param selectSql 用于执行的select语句
* @param
* @return int
*/
public int queryCountNum(String selectSql){
int count=0;
try {
selectPro = dbConnection.createStatement();//定义Statement对象
dbResultSet = selectPro.executeQuery(selectSql);
if(dbResultSet.next()) {
count = dbResultSet.getInt(1);
}
dbResultSet.close(); //断开结果集
selectPro.close(); //断开Statement对象
System.out.println("查询SQl：" + selectSql);
}catch(Exception e) {
System.out.println("操作异常 = " + selectSql);
e.printStackTrace();
// log.error(e.getMessage(),e);;
}finally{
this.closeDatabase();
}
return count;
}
/**
* 执行 查询，返回一个 list 集合
* 执行专门的select操作，将 select 查询语句后的字段自动 封装在一个Map（适合多表查询）
* @param selectSql 用于执行的select语句
* @param
* @return 含有Map的ArrayList，一条记录形成一个Map
*/
@SuppressWarnings("static-access")
// public Map queryForObject(String selectSql)
// {
//// ArrayList<Map> selectResult = new ArrayList<Map>();
// Object obj=null;
// Map recordInfo;
// try {
// selectPro = dbConnection.createStatement();//定义Statement对象
// System.out.println("JDBC 查询： " + selectSql);
// dbResultSet = selectPro.executeQuery(selectSql);
//
// String[] colNames = new ORMClassSql().getColNames(dbResultSet);//得到select后的字段,多表也可以
// int len=colNames.length;
// if(dbResultSet.next()) {
// recordInfo = new HashMap();
// for(int i = 0; i<len; ++i)
// recordInfo.put((String)colNames[i], dbResultSet.getString((String)colNames[i]));
//// selectResult.add(recordInfo);
// }
// dbResultSet.close(); //断开结果集
// selectPro.close(); //断开Statement对象
// }catch(Exception e) {
// System.out.println("选择操作失败");
// System.out.println("失败Sql = " + selectSql);
// e.printStackTrace();
// }finally{
// this.closeDatabase();
// }
// return recordInfo;
// }
/**
* 执行 查询，返回一个 Object 集合
* 执行专门的select操作，注意：在selectSql中的字段和fields中的个数、名称要保持一致
* @param selectSql 用于执行的select语句
* @param fields 要选择的字段
* @return 含有Map的ArrayList，一条记录形成一个Map
*/
public ArrayList queryForObject(String selectSql, ArrayList fields,Object objnaem){
ArrayList<Map> selectResult = new ArrayList<Map>();
Map<String, String> recordInfo;
try {
selectPro = dbConnection.createStatement();//定义Statement对象
dbResultSet = selectPro.executeQuery(selectSql);
while(dbResultSet.next()) {
recordInfo = new HashMap<String, String>();
for(int i = 0; i<fields.size(); ++i)
recordInfo.put((String)fields.get(i), dbResultSet.getString((String)fields.get(i)));
selectResult.add(recordInfo);
}
// Map map= new HashMap();
// int MaxLevel=0;
// for (int j = 0; j < list.size(); j++){
// map=(Map) list.get(j);
// String s= map.get("orderTime").toString();
dbResultSet.close(); //断开结果集
selectPro.close(); //断开Statement对象
}catch(Exception e) {
System.out.println("选择操作失败");
System.out.println("Sql = " + selectSql);
e.printStackTrace();
// log.error(e.getMessage(),e);;
}
return selectResult;
}
/**
* 对数据库执行 update，delete或insert操作
* @param sql 要执行操作的SQL语句
* @return 执行成功返回true，失败返回false
*/
public boolean dbUpdate(String sql){
try
{
// Transaction trans=dbConnection.;
dbConnection.setAutoCommit(false);//不自动提交
updatePro = dbConnection.createStatement(); //定义Statement对象
updatePro.executeUpdate(sql);
System.out.println("更新语句JDBC: "+sql);
dbConnection.commit();
updatePro.close();// -------------关闭Statement对象
return true;
}catch(Exception err) {
try {
dbConnection.rollback();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
// log.error(e.getMessage(),e);;
}
System.out.println("数据库操作失败Sql："+sql);
err.printStackTrace();
return false;
}finally{
this.closeDatabase();
}
}
/**
* 使用执行更新SQl语句(带参数) 预编译
* @param sql String 要执行的SQL语句
* @param paras Object[] SQL参数列表
* @throws DBException
* @return boolean 更新 true成功 false失败
*/
public boolean PreparedStatementUpdate(String sql, Object[] paras){
try{
dbConnection.setAutoCommit(false);//不自动提交
pstmt = dbConnection.prepareStatement(sql);
this.setPreparedStatementParas(pstmt, paras);
System.out.println("更新语句JDBC: "+sql);
int result = pstmt.executeUpdate();
dbConnection.commit();
updatePro.close();// -------------关闭Statement对象
return true;
}catch (Exception err) {
try {
dbConnection.rollback();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
// log.error(e.getMessage(),e);;
}
System.out.println("数据库操作失败Sql："+sql);
err.printStackTrace();
return false;
}finally{
this.closeDatabase();
}
}
/**
* 实现Object数组表示的参数列表和SQL语句中的"?" 预编译 绑定
* @param pstmt PreparedStatement
* @param paras Object[]
* @throws SQLException
*/
private void setPreparedStatementParas(PreparedStatement pstmt, Object[] paras) throws SQLException {
if (paras != null && paras.length > 0) {
for (int i = 0; i < paras.length; i++) {
if (paras[i] == null) {
//注意，SQL不支持java.sql.Types.NULL，所以使用java.sql.Types.VARCHAR代替
pstmt.setNull(i + 1, java.sql.Types.VARCHAR);
}else {
//begin from index 1
pstmt.setObject(i + 1, paras[i]);
}
}
}
}
/*
* 跟踪
*/
public String getTrace(Throwable t) {
StringWriter stringWriter= new StringWriter();
PrintWriter writer= new PrintWriter(stringWriter);
t.printStackTrace(writer);
StringBuffer buffer= stringWriter.getBuffer();
return buffer.toString();
}
/*..........................................................封装查询模版......................................................................*/
/**
* 执行 查询，返回一个 list 集合
* 执行专门的select操作，将 select 查询语句后的字段自动 封装在一个Map（适合多表查询）
* @param selectSql 用于执行的select语句
* @param 多个查询的模版
*
* @return modelObjectVo 对象
*/
@SuppressWarnings("static-access")
public modelObjectVo queryForModel(String selectSql){
ArrayList<Map> selectResult = new ArrayList<Map>();
Map<String, String> recordInfo;
String[] colNames = null;
modelObjectVo obj = new modelObjectVo();
try {
selectPro = dbConnection.createStatement();//定义Statement对象
System.out.println("JDBC 查询： " + selectSql);
dbResultSet = selectPro.executeQuery(selectSql);
colNames = new ORMClassSql().getColNames(dbResultSet);//得到select后的字段,多表也可以
int len=colNames.length;
while(dbResultSet.next()) {
recordInfo = new HashMap<String, String>();
for(int i = 0; i<len; ++i){
recordInfo.put((String)colNames[i], dbResultSet.getString((String)colNames[i]));
selectResult.add(recordInfo);
}
}
obj.setColNames(colNames);
obj.setQueryList(selectResult);
dbResultSet.close(); //断开结果集
selectPro.close(); //断开Statement对象
}catch(Exception e) {
System.out.println("选择操作失败");
System.out.println("失败Sql = " + selectSql);
e.printStackTrace();
// log.error(e.getMessage(),e);;
}finally{
this.closeDatabase();
}
return obj;
}
/**
*
* @param con
* @return
* @description 批量执行sql
* @version 1.0
* @author liutao
* @update Apr 19, 2013 5:50:57 PM
*/
public static boolean supportBatch(Connection con){
try{
DatabaseMetaData md=con.getMetaData();
return md.supportsBatchUpdates();
}catch(SQLException e){
e.printStackTrace();
}
return false;
}
/**
*
* @param con
* @param sqls
* @return
* @description 将多条 增、删、改等批量的操作
* @version 1.0
* @author liutao
* @throws SQLException
* @update Apr 19, 2013 5:51:57 PM
*/
public int[] goBatch(Connection con,String[] sqls){
int[] result = null;
if(sqls==null){
return null;
}
try{
selectPro = con.createStatement();
con.setAutoCommit(false);
for(int i=0;i<sqls.length;i++){
selectPro.addBatch(sqls[i]);
}
result = selectPro.executeBatch();
con.commit();
}
catch(SQLException e){
try {
con.rollback();
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
e.printStackTrace();
}finally{
this.closeDatabase();
}
return result;
}
// /**
// *
// * 执行SQl 语句返回一个结果集
// * @param 用于执行的select语句
// * @param
// * @return ResultSet
// */
// @SuppressWarnings("static-access")
// public ResultSet queryResultSet(String selectSql){
// try {
// selectPro = dbConnection.createStatement();//定义Statement对象
// System.out.println("JDBC 查询： " + selectSql);
// dbResultSet = selectPro.executeQuery(selectSql);
//
//// dbResultSet.close(); //断开结果集
//// selectPro.close(); //断开Statement对象
// }catch(Exception e) {
// System.out.println("选择操作失败");
// System.out.println("失败Sql = " + selectSql);
// e.printStackTrace();
//// log.error(e.getMessage(),e);;
// }finally{
// this.closeDatabase();
// }
// return dbResultSet;
// }
// /**
// * @param 获取select 后的字段，放在一个String数组中
// * @return String[]
// * 2013-02-22
// * @author liutao
// */
// public static String[] getColNames(ResultSet dbResultSet){
// String[] colNames = null;
// try {
// colNames = ORMClassSql.getColNames(dbResultSet);
// } catch (SQLException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// return colNames;
// }
// /**
// * 执行 查询，返回一个 list 集合 多个模版
// * 将ResultSet 结果集 封装在一个Map（适合多表查询）
// * @param selectSql 用于执行的select语句
// * @param
// * @return 含有Map的ArrayList，一条记录形成一个Map
// */
// public ArrayList getResultSet2List(ResultSet dbResultSet) {
//
// ArrayList<Map> selectResult = new ArrayList<Map>();
// Map<String, String> recordInfo;
//
// String[] colNames;
// try {
// colNames = new ORMClassSql().getColNames(dbResultSet);
// int len=colNames.length;
// while(dbResultSet.next()) {
// recordInfo = new HashMap<String, String>();
// for(int i = 0; i<len; ++i)
// recordInfo.put((String)colNames[i], dbResultSet.getString((String)colNames[i]));
// selectResult.add(recordInfo);
// }
//
// } catch (SQLException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }//得到select后的字段,多表也可以
//
// return selectResult;
// }
//
//
//
// public static void main(String[] args){
// String dbHost = "localhost";
// String dbPort = "3306";
// String dbName = "test";
// String dbUserName = "root";
// String dbPassword = "";
// DbConnection conn = new DbConnection(dbHost, dbPort, dbName, dbUserName, dbPassword);
// boolean bool = conn.dbConnection();
// if(!bool)
// return;
// String selectSql = "select user_name, ad from user_info where age = 23";
// ArrayList<String> fieldsList = new ArrayList<String>();
// fieldsList.add("user_name");
// fieldsList.add("ad");
// ArrayList<Map> userInfoList = conn.dbSelect(selectSql, fieldsList);
// int infoSize = userInfoList.size();
// String userName;
// String ad;
// if(infoSize == 0){
// System.out.println("没有选出符合条件的数据");
// }
// else{
// for(int i = 0; i < infoSize; ++i){
// userName = (String)userInfoList.get(i).get("user_name");
// ad = (String)(((Map)userInfoList.get(i)).get("ad"));
// System.out.println("userName = " + userName + " ad = " + ad);
// }
// }
// conn.closeDatabase();
// }//end main( )
}//end calss DbConnection
2。反射
package com.coffee.databaseservices.database.DBConnection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class ORMClassSql {
/**
* @param args
* @throws Exception
* @throws InvocationTargetException
* @throws IllegalAccessException
* @throws SQLException
*/
public static void main(String[] args) throws SQLException,
IllegalAccessException, InvocationTargetException, Exception {
}
/**
* 将selcet 后 字段 封装到javaBean对象 List集合中(只限于单表查询)
*
* @param clazz
* ：对象所属的类
* @param conn
* ：连接数据库
* @return:集合list
*
*/
public List<Object> getObjectsForList(String sql, Class clazz,Connection conn) {
//Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
List<Object> list = new ArrayList<Object>();
try {
//conn = JdbcUtils.getConnection();
ps = conn.prepareStatement(sql);
rs = ps.executeQuery();
System.out.println("查询语句JDBC: "+sql);
String[] colNames = getColNames(rs);
Method[] ms = clazz.getMethods();
while (rs.next()) {
Object object = clazz.newInstance();
for (int i = 0; i < colNames.length; i++) {
String colName_table = colNames[i];
String colName=this.ChangeFirstToUpper(colName_table);
String methodName = "set" + colName;
Object rstObj = rs.getObject(colName_table);
if(rstObj != null){
Object value = String.valueOf(rs.getObject(colName_table));
try{
Method m = clazz.getMethod(methodName, value.getClass());
if (m != null)
m.invoke(object, value);
}catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
// Object value = rs.getObject(colName);
// try {
// Method m = clazz
// .getMethod(methodName, value.getClass());
// if (m != null)
// m.invoke(object, value);
// } catch (NoSuchMethodException e) {
// e.printStackTrace();
// //
// }
// for (Method m : ms) {
// if (methodName.equals(m.getName())) {
// m.invoke(object, rs.getObject(colName));
// break;
// }
// }
}
list.add(object);
}
}catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
finally {
new DbConnection().closeDatabase();
}
return list;
}
/**
* 将selcet 后 字段 封装到javaBean 对象中(只限于单表查询)
*
* @param clazz
* ：对象所属的类
* @param conn
* ：连接数据库
* @return:集合list
*
*/
public Object getObject(String sql, Class clazz,Connection conn) throws SQLException, Exception, IllegalAccessException,
InvocationTargetException {
// Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
Object object = null;
try {
//conn = JdbcUtils.getConnection();
ps = conn.prepareStatement(sql);
System.out.println("查询语句JDBC: "+sql);
rs = ps.executeQuery();
//System.out.println("查询结果集:"+rs);
String[] colNames = getColNames(rs);
Method[] ms = clazz.getMethods();
if (rs.next()) {
object = clazz.newInstance();
for (int i = 0; i < colNames.length; i++) {
String colName_table = colNames[i];
String colName=this.ChangeFirstToUpper(colName_table);
String methodName = "set" + colName;
Object rstObj = rs.getObject(colName_table);
if(rstObj != null){
Object value = String.valueOf(rs.getObject(colName_table));
try{
Method m = clazz.getMethod(methodName, value.getClass());
if (m != null)
m.invoke(object, value);
}catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
// if(NullTosafe())
// for (Method m : ms) {
// if (methodName.equals(m.getName())) {
// m.invoke(object, rs.getObject(colName_table));
// //break;
// }
// }
}
}
return object;
}finally {
new DbConnection().closeDatabase();
}
}
/**
* @param str
* @return
* @description 将某个字符串首字母大写
* @version 1.0
* @author liutao
* @update Apr 20, 2013 1:56:40 PM
*/
public static String ChangeFirstToUpper(String str){
String rtnStr="";
if(str.equals(null)|| str.equals("")){
return "";
}
String str1=str.substring(0,1).toUpperCase();//直接将字符串第一个不管是数字还是字母都大写
String str2=str.substring(1,str.length());//截取字符串第二个以后
rtnStr=str1+str2;
return rtnStr;
}
public String NullTosafe(String str){
if(str.equals(null)|| str.equals("") || str.equals("undefined")){
return "";
}
return str;
}
/*
* 获取select 后面的字段
* @return String[]
*/
public static String[] getColNames(ResultSet rs) throws SQLException {
ResultSetMetaData rsmd = rs.getMetaData();
int count = rsmd.getColumnCount();
String[] colNames = new String[count];
for (int i = 1; i <= count; i++) {
colNames[i - 1] = rsmd.getColumnLabel(i);
}
return colNames;
}
}
3.工具类
package com.coffee.databaseservices.database.DBConnection;
import java.lang.reflect.InvocationTargetException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.coffee.bean.db.accounts.modelObjectVo;
import com.mysql.jdbc.Connection;
public class DBTools {
// start *****************************************************内部数据库用*************************************************
/*
* 连接的数据库，查询游戏数据库数据库中的 条目数
* return intNum
*/
public static int getCount(String sgDatabaseIp,String sgDatabasePort,String sgDatabaseName,
String sgUserName,String sgDatabasePassword,String sql) {
int totalRecordNum=0;
DbConnection bdconn=new DbConnection(sgDatabaseIp,sgDatabasePort,sgDatabaseName,sgUserName,sgDatabasePassword);//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
totalRecordNum =bdconn.queryCountNum(sql);
bdconn.closeDatabase();
}
return totalRecordNum;
}
/*
* 连接的数据库，查询游戏数据库中的 list <Map> 集合
* 每条集合包含一个list 适合单表或者多表查询 根据select 后的字段自行封装
* return list
*
*/
public static List getForList(String sgDatabaseIp,String sgDatabasePort,String sgDatabaseName,
String sgUserName,String sgDatabasePassword,String sql) {
List list=null;
DbConnection bdconn=new DbConnection(sgDatabaseIp,sgDatabasePort,sgDatabaseName,sgUserName,sgDatabasePassword);//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
list=bdconn.queryForList(sql);
bdconn.closeDatabase();
}
return list;
}
/*
* 连接的数据库，查询游戏数据库中的 list <vo> 集合
* 每条集合包含一个list 适合单表或者多表查询 根据select 后的字段自行封装
* clazz 要封装的 VO
* return list
*/
public static List getObjectForList(String sgDatabaseIp,String sgDatabasePort,String sgDatabaseName,
String sgUserName,String sgDatabasePassword,String sql,Class clazz) {
List list=null;
DbConnection bdconn=new DbConnection(sgDatabaseIp,sgDatabasePort,sgDatabaseName,sgUserName,sgDatabasePassword);//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
Connection conn=(Connection) bdconn.getDbConnection();
list=new ORMClassSql().getObjectsForList(sql, clazz, conn);
bdconn.closeDatabase();
if (conn!=null) {
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return list;
}
/*
* 连接的数据库，查询游戏数据库中的 单条 Vo 集合
* 适合单表或者多表查询 根据select 后的字段自行封装成一个 javaBean
* clazz 要封装的 VO
* return list
*/
public static Object getObjectForBean(String sgDatabaseIp,String sgDatabasePort,String sgDatabaseName,
String sgUserName,String sgDatabasePassword,String sql,Class clazz) {
Object obj=null;
DbConnection bdconn=new DbConnection(sgDatabaseIp,sgDatabasePort,sgDatabaseName,sgUserName,sgDatabasePassword);//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
Connection conn=(Connection) bdconn.getDbConnection();
try {
obj=new ORMClassSql().getObject(sql, clazz, conn);
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IllegalAccessException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (InvocationTargetException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}finally{
bdconn.closeDatabase();
if (conn!=null) {
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
return obj;
}
/*
* 连接的数据库，查询游戏数据库中的 list <Map>集合
* 每条集合包含一个list 适合单表或者多表查询 根据select
* fields 保留想要封装的字段
* return list
*/
public static List getForList(String sgDatabaseIp,String sgDatabasePort,String sgDatabaseName,
String sgUserName,String sgDatabasePassword,String sql,ArrayList fields) {
List list=null;
DbConnection bdconn=new DbConnection(sgDatabaseIp,sgDatabasePort,sgDatabaseName,sgUserName,sgDatabasePassword);//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
list=bdconn.queryForList(sql,fields);
bdconn.closeDatabase();
}
return list;
}
/*
* 连接的数据库，对数据库 增、删、改 操作
* return intNum
*/
public static int dbUpdateForServer(String sgDatabaseIp,String sgDatabasePort,String sgDatabaseName,
String sgUserName,String sgDatabasePassword,String sql) {
boolean updateFlag=false;
int updateflag=0;
DbConnection bdconn=new DbConnection(sgDatabaseIp,sgDatabasePort,sgDatabaseName,sgUserName,sgDatabasePassword);//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
updateFlag=bdconn.dbUpdate(sql);
if(!updateFlag){
System.out.println("插入操作失败");
}else{
updateflag=1;
}
}
return updateflag;
}
/*
* 连接的数据库，对数据库 增、删、改 操作
* 预编译
* return intNum
*/
public static int dbPreparedUpdateForServer(String sgDatabaseIp,String sgDatabasePort,String sgDatabaseName,
String sgUserName,String sgDatabasePassword,String sql,Object[] paras) {
boolean updateFlag=false;
int updateflag=0;
DbConnection bdconn=new DbConnection(sgDatabaseIp,sgDatabasePort,sgDatabaseName,sgUserName,sgDatabasePassword);//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
updateFlag=bdconn.PreparedStatementUpdate(sql,paras);
if(!updateFlag){
System.out.println("插入操作失败");
}else{
updateflag=1;
}
}
return updateflag;
}
// end *****************************************************内部数据库用*************************************************
// start *****************************************************外部数据库用*************************************************
/*
* 连接的数据库，对数据库 增、删、改 操作
* return intNum
*/
public static int dbUpdate(String sql) {
boolean updateFlag=false;
int updateflag=0;
DbConnection bdconn=new DbConnection();//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
updateFlag=bdconn.dbUpdate(sql);
if(!updateFlag){
System.out.println("插入操作失败");
}else{
updateflag=1;
}
}
return updateflag;
}
/*
* 连接的数据库，对数据库 增、删、改 操作
* 预编译
* return intNum
*/
public static int dbPreparedUpdate(String sql,Object[] paras) {
boolean updateFlag=false;
int updateflag=0;
DbConnection bdconn=new DbConnection();//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
updateFlag=bdconn.PreparedStatementUpdate(sql,paras);
if(!updateFlag){
System.out.println("插入操作失败");
}else{
updateflag=1;
}
}
return updateflag;
}
/*
* 连接的数据库，查询Account 数据库中的条目数
* return intNum
*/
public static int getAccountCount(String sql) {
int totalRecordNum=0;
DbConnection bdconn=new DbConnection();//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
totalRecordNum =bdconn.queryCountNum(sql);
bdconn.closeDatabase();
}
return totalRecordNum;
}
/*
* 连接的数据库，查询account 数据库游戏数据库中的 list <Map> 集合
* 每条集合包含一个list 适合单表或者多表查询 根据select 后的字段自行封装
* return list
*/
public static List getAccount_ForList(String sql) {
List list=null;
DbConnection bdconn=new DbConnection();//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
list=bdconn.queryForList(sql);
bdconn.closeDatabase();
}
return list;
}
/*
* 连接的数据库，查询游戏数据库中的 单条 Vo 集合
* 适合单表或者多表查询 根据select 后的字段自行封装成一个 javaBean
* clazz 要封装的 VO
* return list
*/
public static Object getAccountObjectForBean(String sql,Class clazz) {
Object obj=null;
DbConnection bdconn=new DbConnection();//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
Connection conn=(Connection) bdconn.getDbConnection();
try {
obj=new ORMClassSql().getObject(sql, clazz, conn);
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IllegalAccessException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (InvocationTargetException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}finally{
bdconn.closeDatabase();
if (conn!=null) {
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
return obj;
}
/*
* 连接的数据库，查询游戏数据库中的 list <Map> 集合
* 每条集合包含一个list 适合单表或者多表查询 根据select
* fields 保留想要封装的字段
* return list
*/
@SuppressWarnings("unchecked")
public static List getAccount_ForList(String sql,ArrayList fields) {
List list=null;
DbConnection bdconn=new DbConnection();//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
list=bdconn.queryForList(sql,fields);
bdconn.closeDatabase();
}
return list;
}
// end *****************************************************外部数据库用*************************************************
/*........................................多条查询共通模版...................................................................*/
/**
*
* 执行SQl 语句返回一个结果集
* @param 用于执行的select语句
* * 2013-02-22
* @author liutao
* @return modelObjectVo queryForModel
*/
public static modelObjectVo queryForModel(String sgDatabaseIp,String sgDatabasePort,String sgDatabaseName,
String sgUserName,String sgDatabasePassword,String sql) {
modelObjectVo obj= new modelObjectVo();
DbConnection bdconn=new DbConnection(sgDatabaseIp,sgDatabasePort,sgDatabaseName,sgUserName,sgDatabasePassword);//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if(flag){
obj = bdconn.queryForModel(sql);
bdconn.closeDatabase();
}
return obj;
}
/**
*
* @param sgDatabaseIp
* @param sgDatabasePort
* @param sgDatabaseName
* @param sgUserName
* @param sgDatabasePassword
* @param sqls
* @return
* @description 执行批量sql语句(增、删、改等批量的sql操作)
* @version 1.0
* @author liutao
* @update Apr 20, 2013 9:41:18 AM
*/
@SuppressWarnings("static-access")
public static int[] exeBatch(String[] sqls){
int[] result= null;
DbConnection bdconn=new DbConnection();//连接数据初始化
boolean flag =bdconn.dbConnectionSuccess();//返回连接对象 ，false为连接失败 true 为成功
if (flag) {
java.sql.Connection con =bdconn.getDbConnection();
boolean flags = bdconn.supportBatch(con);
if (flags) {
result = bdconn.goBatch(con, sqls);
}
}
return result;
}
}
下面是完整的下载包，代码难免有缺陷，忘多多指点
相关推荐
Java JDBC封装类，带增删改查例子，支持oracle,MySql,hsqldb 等，支持事务，返回数据格式 支持二维数组，MAP格式，以及javabean对象。有利于初学者DbDemo.java为demo,Connect为jdbc封装类，可以作为项目共通类使用。
JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试JDBC连接数据库测试...
JDBC连接数据库工具类 JDBC 连接数据库 ORACLE SQLSERVER MYSQL ORACLE 已测 OK 欢迎大家反馈 我的微博是： http://weibo.com/namenode
jdbc java 数据库 连接数据库 步骤
JDBC 连接数据库方法文档 JDBC（Java Database Connectivity）是 Java 语言中用于连接数据库的标准 API。它提供了一种统一的方式来访问各种类型的数据库，包括关系数据库、对象数据库和文本数据库等。下面是 JDBC ...
java用于jdbc的连接的实现类,在数据库连接的时候直接new出来就OK了!DAO层自己加写...
### JDBC连接数据库步骤详解 #### 一、简介 在Java开发中，经常需要与数据库进行交互，例如查询数据、更新数据等操作。为了方便开发者进行这些操作，Sun公司推出了一套标准的Java访问数据库的API——Java Database...
JDBC（Java Database Connectivity）是Java语言中用于连接和操作数据库的应用程序接口。它定义了Java应用程序如何与数据库之间通信，允许用户执行SQL语句并获取结果。对于初学者来说，理解JDBC连接数据库的基本步骤...
JDBC连接数据库工具类 JDBC 连接数据库 ORACLE SQLSERVER MYSQL ORACLE 已测 OK 欢迎大家反馈
JDBC提供了统一的接口，使得Java程序可以连接到不同的数据库管理系统（DBMS）。本篇将详细介绍如何使用JDBC连接数据库，并通过一个简单的示例进行讲解。 首先，要连接到数据库，我们需要确保已经正确地在项目中引入...
jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc连接数据库jdbc...
### JDBC连接数据库类知识点解析 #### 一、JDBC简介 Java Database Connectivity (JDBC) 是 Java 中一种用于执行 SQL 语句的标准 API，它由一组用 Java 编程语言编写的类和接口组成。JDBC 可为多种关系型数据库...
### JDBC连接数据库各种数据库参数详解 #### 一、Oracle8/8i/9i数据库（thin模式） 在Java中通过JDBC访问Oracle数据库时，通常采用thin驱动方式。thin驱动是一种纯Java驱动，无需依赖任何非Java代码即可完成与...
为了在Java中使用JDBC连接Oracle数据库，需要创建一个封装类，这个类将遵循JavaBean规范，其中包含私有属性、公有的set/get方法、无参构造函数。这个封装类作为数据库操作的实体类，用来封装查询到的数据。 接着，...
JDBC连接数据库JDBC连接数据库
JDBC（Java Database Connectivity）是Java编程语言中用于与各种数据库进行交互的一种API。它提供了一种标准的方式来访问和操作数据库，使得开发人员无需关心具体的数据库实现细节，就能执行SQL语句并处理结果。JDBC...
"JDBC 连接数据库" JDBC（Java Database Connectivity）是一种Java API，用于连接数据库，并执行 SQL 语句以访问和操作数据库中的数据。JDBC API 由java.sql包提供，包括了 Connection、Statement、ResultSet 等...
### 完整Java开发中JDBC连接数据库代码和步骤 #### 一、概述 在Java开发过程中，通过Java Database Connectivity (JDBC) 连接数据库是非常常见的一种操作方式。JDBC提供了一组标准的API，使得Java应用程序可以访问...