jdbc 连接数据库封装类，可返回map，或者vo（自用）

myCsdn_taoge

浏览: 38616 次
性别:
来自: 沈阳

最近访客更多访客>>

ABuFan

tangjiankang

leroy_boy

mingjing2519

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

随笔

jdbc 连接数据库封装类

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;
		
	}
	
	
    
}

下面是完整的下载包，代码难免有缺陷，忘多多指点

DBConnection.rar (10.2 KB)
下载次数: 6

分享到：

js 判断select 选中值，以及radiobutton ... | ssh 框架常用的3中数据库连接池

2013-11-09 11:59
浏览 2998
评论(0)
分类:互联网
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

jdbc 连接数据库封装类，可返回map，或者vo（自用）

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

jdbc 连接数据库封装类，可返回map，或者vo（自用）

评论

发表评论

相关推荐

淘宝买下双色球所有的注数，闲来无事写了一下双色球所有注数的算法

周鸿祎在360新员工入职培训上的讲话

最近访客更多访客>>