JDBC工具类 带有编码转换

JDBC工具类 不多解释了 注释写的挺全的

package com.sdu.utils;

import java.io.UnsupportedEncodingException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

/**
 * @类功能说明：JDBC工具类
 * @公司名称：jinhou
 * @作者：WeiYC
 * @创建时间：2015-1-26 上午10:41:52
 */
public class JDBCUtility {
	private Connection conn;
	private Statement st;
	private PreparedStatement pps;
	private ResultSet rs;
	public String url = DBPropertiesUtility.getUrl();
	private String user = DBPropertiesUtility.getUser();
	private String password = DBPropertiesUtility.getPwd();
	private static String driver1 = "oracle.jdbc.driver.OracleDriver";
	
	private static String driver2 = "com.mysql.jdbc.Driver";
	
	// 加载驱动、放在静态代码块中，保证驱动在整个项目中只加载一次，提高效率
	static {
		try {
//			String driver = DBPropertiesUtility.getDriver(); 
			Class.forName(driver1);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获取连接的方法
	 * 
	 * @return Connection 一个有效的数据库连接
	 */
	public Connection getConnection() {
		try {
			// 注意链接时，要换成自己的数据库名，数据库用户名及密码
			Connection con = DriverManager.getConnection(url, user, password);
			return con;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 用于执行更新的方法,包括（insert delete update）操作
	 * 
	 * @param sql
	 *            String 类型的SQL语句
	 * @return Integer 表示受影响的行数
	 */
	public int update(String sql) {
		// 定义变量用来判断更新操作是否成功，如果返回-1说明没有影响到更新操作的数据库记录条数，即更新操作失败
		int row = -1;
		try {
			// 如果数据库链接被关闭了，就要既得一个新的链接
			if (conn == null || conn.isClosed()) {
				conn = getConnection();
			}
			// 使用Connection对象conn的createStatement()创建Statement（数据库语句对象）st
			st = conn.createStatement();
			// 执行更新操作，返回影响的记录条数row
			row = st.executeUpdate(sql);
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close();
		}
		return row;
	}

	/**
	 * 基于PreparedStatement的修改方法 PreparedStatement:表示预编译的 SQL 语句的对象
	 * 
	 * @param sql
	 *            String 类型的SQL语句（insert delete update）
	 * @param obj
	 *            存放动态参数的数组
	 * @return Integer 表示受影响的行数
	 */
	public int update(String sql, Object... obj) {
		try {
			// 获取链接
			if (conn == null || conn.isClosed()) {
				conn = getConnection();
			}
			// 创建预编译的 SQL 语句对象
			pps = conn.prepareStatement(sql);
			// 定义变量length代表数组长度，也就是预处理的sql语句中的参数个数
			int length = 0;
			// ParameterMetaData：用于获取关于 PreparedStatement 对象中每个参数的类型和属性信息的对象
			ParameterMetaData pmd = pps.getParameterMetaData();
			length = pmd.getParameterCount();
			// 循环将sql语句中的?设置为obj数组中对应的值，注意从1开始，所以i要加1
			for (int i = 0; i < length; i++) {
				pps.setObject(i + 1, obj[i]);
			}
			// 执行更新操作
			return pps.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close();
		}

		return -1;
	}

	/**
	 * 获取一条记录的方法，要依赖于下面的queryToList方法，注意泛型的使用
	 * 
	 * @param sql
	 * @return　Map<String,Object>
	 */
	public Map<String, Object> getOneRow(String sql) {
		// 执行下面的queryToList方法
		List<Map<String, Object>> list = queryToList(sql);
		// 三目运算，查询结果list不为空返回list中第一个对象,否则返回null
		return list.size() > 0 ? list.get(0) : null;
	}

	/**
	 * 返回查询结果列表，形如：[{TEST_NAME=aaa, TEST_NO=2, TEST_PWD=aaa}, {TEST_NAME=bbb,
	 * TEST_NO=3, TEST_PWD=bbb}...]
	 * 
	 * @param sql
	 * @return List<Map<String,Object>>
	 */
	public List<Map<String, Object>> queryToList(String sql) {
		// 创建集合列表用以保存所有查询到的记录
		List<Map<String, Object>> list = new LinkedList<Map<String, Object>>();
		try {
			if (conn == null || conn.isClosed()) {
				conn = getConnection();
			}
			st = conn.createStatement();
			rs = st.executeQuery(sql);
			// ResultSetMetaData 是结果集元数据，可获取关于 ResultSet 对象中列的类型和属性信息的对象
			// 例如：结果集中共包括多少列，每列的名称和类型等信息
			ResultSetMetaData rsmd = rs.getMetaData();
			// 获取结果集中的列数
			int columncount = rsmd.getColumnCount();
			// while条件成立表明结果集中存在数据
			while (rs.next()) {
				// 创建一个HashMap用于存储一条数据
				HashMap<String, Object> onerow = new HashMap<String, Object>();
				// 循环获取结果集中的列名及列名所对应的值，每次循环都得到一个对象，形如：{TEST_NAME=aaa, TEST_NO=2,
				// TEST_PWD=aaa}
				for (int i = 0; i < columncount; i++) {
					// 获取指定列的名称，注意orcle中列名的大小写
					String columnName = rsmd.getColumnName(i + 1);
					//进行编码设置
					int type = rsmd.getColumnType(i+1);
					if(type==Types.CHAR||type==Types.VARCHAR||type==Types.LONGVARCHAR){
						if(!CommonUtility.isEmpty(rs.getString(i+1))){
							String value="";
							try {
								 value = new String(rs.getString(i+1).getBytes("ISO-8859-1"),"GBK");
							} catch (UnsupportedEncodingException e) {
								e.printStackTrace();
							}
							onerow.put(columnName, value);
							System.out.println("列名："+columnName+"   值："+value);
						}
					}else{
						onerow.put(columnName, rs.getObject(i + 1));
						System.out.println("列名："+columnName+"   值："+rs.getObject(i + 1));
					}
				}
				// 将获取到的对象onewrow={TEST_NAME=aaa, TEST_NO=2,
				// TEST_PWD=aaa}放到集合列表中
				list.add(onerow);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close();
		}
		return list;
	}

	/**
	 * 返回查询结果列表,使用的是预编绎SQL 语句对象PreparedStatement 形如：[{TEST_NAME=aaa, TEST_NO=2,
	 * TEST_PWD=aaa}, {TEST_NAME=bbb, TEST_NO=3, TEST_PWD=bbb}]
	 * 
	 * @param sql
	 * @param paramValues
	 * @return List<Map<String,Object>>
	 */
	public List<Map<String, Object>> queryWithParam(String sql,
			Object... paramValues) {
		// 创建集合列表用以保存所有查询到的记录
		List<Map<String, Object>> list = new LinkedList<Map<String, Object>>();
		try {
			if (conn == null || conn.isClosed()) {
				conn = getConnection();
			}
			pps = conn.prepareStatement(sql);
			for (int i = 0; i < paramValues.length; i++) {
				pps.setObject(i + 1, paramValues[i]);
			}
			rs = pps.executeQuery();
			// ResultSetMetaData 是结果集元数据，可获取关于 ResultSet 对象中列的类型和属性信息的对象
			// 例如：结果集中共包括多少列，每列的名称和类型等信息
			ResultSetMetaData rsmd = rs.getMetaData();
			// 获取结果集中的列数
			int columncount = rsmd.getColumnCount();
			// while条件成立表明结果集中存在数据
			while (rs.next()) {
				// 创建一个HashMap用于存储一条数据
				HashMap<String, Object> onerow = new HashMap<String, Object>();
				// 循环获取结果集中的列名及列名所对应的值，每次循环都得到一个对象，形如：{TEST_NAME=aaa, TEST_NO=2,
				// TEST_PWD=aaa}
				for (int i = 0; i < columncount; i++) {
					// 获取指定列的名称，注意orcle中列名的大小写
					String columnName = rsmd.getColumnName(i + 1);
					//进行编码设置
					int type = rsmd.getColumnType(i+1);
					if(type==Types.CHAR||type==Types.VARCHAR||type==Types.LONGVARCHAR){
						if(!CommonUtility.isEmpty(rs.getString(i+1))){
							String value="";
							try {
								 value = new String(rs.getString(i+1).getBytes("ISO-8859-1"),"GBK");
							} catch (UnsupportedEncodingException e) {
								e.printStackTrace();
							}
							onerow.put(columnName, value);
						}
					}else{
						onerow.put(columnName, rs.getObject(i + 1));
					}
				}
				// 将获取到的对象onewrow={TEST_NAME=aaa, TEST_NO=2,
				// TEST_PWD=aaa}放到集合列表中
				list.add(onerow);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close();
		}
		return list;
	}

	/**
	 * 关闭数据库各种资源Connection Statement PreparedStatement ResultSet的方法
	 */
	private void close() {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}

		if (st != null) {
			try {
				st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if (pps != null) {
			try {
				pps.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		try {
			if (conn != null && !conn.isClosed()) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String args[]){
		JDBCUtility db = new JDBCUtility();
		Map<String,Object> map = db.getOneRow("select * from HIS_BASE_DEPARTMENT");
		System.out.println(map.get("DESCN"));
	}
		
}

配置文件获取类

package com.sdu.utils;
import java.io.IOException;
import java.util.Properties;

import com.sdu.utils.mail.PropertiesUtil;
/**
 * @类功能说明：静态读取数据库配置文件
 * @作者：WeiYC
 * @创建时间：2015-1-26 上午11:31:14
 */
public class DBPropertiesUtility {
	private static Properties pros = new Properties();				
	private static String CONFIG_FILE = "res/jdbc.properties";		//配置文件路径
	/**
	 * 静态执行一段代码，将配置文件读入到内存中
	 */
	static{
		try {
			pros.load(PropertiesUtil.class.getClassLoader().getResourceAsStream(CONFIG_FILE));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
    public static String getDriver(){
    	return pros.getProperty("oracle.driver");
    }
	
    public static String getUrl(){
    	return pros.getProperty("oracle.url");
    }
	
    public static String getUser(){
    	return pros.getProperty("oracle.user");
    }
	
    public static String getPwd(){
    	return pros.getProperty("oracle.password");
    }	
    
    public static void main(String args[]){
    	System.out.println(DBPropertiesUtility.getDriver());
    }
}

 

 

配置文件

#oracle数据库参数
oracle.driver=oracle.jdbc.driver.OracleDriver 
oracle.url=jdbc:oracle:thin:@192.168.1.120:1521:db
oracle.user=dbuser
oracle.password=123456 


#mysql数据库参数
mysql.driver=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://192.168.1.120:3306/db
mysql.username=root
mysql.password=123456
mysql.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

 

项目目录结构