0%

JDBC，通过属性配置文件封装DbUtiles类

发表于 更新于 分类于 阅读次数：
本文字数： 6.2k 阅读时长 ≈ 6 分钟

2017年9月4日 下午4:56

概述：

封装的效果：在逻辑层中，能够通过一个简单的sql语句，就可以拿到一个list对象，这个list对象中包含了自己要查询的数据
改进：在起到封装的效果之后，我们可以在对数据库连接的效率进行优化。因为，当我们每次对一条sql语句进行查询的时候，我们要新建一次与数据库的连接，然后再断开连接。这样周而复始，其实是很浪费数据库资源的，尤其是多用户同时操作数据库时。所以，我们能不能这连接进行复用，而不是一次性的？
改进参考：两种数据库连接池 （2017/9/5）

属性配置文件

建File类型文件 最后起名的时候加上.properties

引用属性配置文件（static）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
	 * 静态代码块   类加载时完成数据初始化
	 */
	static {
		Properties p = new Properties();
		try {
			p.load(DbUtils.class.getClassLoader().getResourceAsStream("com/shanxi/properties/dbUtils.properties"));
			driverUrl = p.getProperty("driverUrl");
			url = p.getProperty("url");
			username = p.getProperty("username");
			password =  p.getProperty("password");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

注意：这里的属性文件的位置，要写全

完整的DbUtiles类 + 属性配置

写这个封装类，学到了以下几点

  1. 如何处理输入数据
    1. 这里要转换成数组输入
  2. 如何处理输出数据
    1. 这要转换成list类型输出
  3. 说白了，其实就是各种类型之间的转换
    1. 转成数组类型
    2. 转成list类型
    3. 转成map类型
    4. 转成字符串类型
    5. 转成其他范式集合类型
    6. 常见的就以上几种

附录代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
package com.shanxi.dbUtils;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;


/*
 * 数据库工具类
 */
public class DbUtils {
	//数据库连接对象  Connection
	private static Connection conn;
	//操作数据库对象Statement
	private static Statement sta;
	//操作数据库预编译对象Preparstatement
	private static PreparedStatement ps;
	//驱动类地址
	private static String driverUrl;
	//URL数据库连接
	private static String url;
	//用户名
	private static String username;
	//密码
	private static String password;
	/*
	 * 静态代码块   类加载时完成数据初始化
	 */
	static {
		Properties p = new Properties();
		try {
			p.load(DbUtils.class.getClassLoader().getResourceAsStream("com/shanxi/properties/dbUtils.properties"));
			driverUrl = p.getProperty("driverUrl");
			url = p.getProperty("url");
			username = p.getProperty("username");
			password =  p.getProperty("password");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	/*
	 * 获取Connection连接的方法
	 * @return conn
	 */
	public static  Connection getConnection() {
		try {
			Class.forName(driverUrl);
			conn = DriverManager.getConnection(url, username, password);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}
	
	/*
	 * 不支持预编译的查询方法 
	 */
	public static List<Map<String,Object>> queryForList(String sql){
		List<Map<String,Object>> list =  new ArrayList<Map<String, Object>>();
		try {
			
			conn = getConnection();
			sta = conn.createStatement();
			ResultSet rs = sta.executeQuery(sql);
			list = rsToList(rs);
			close();
			
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return list;
	}
	/*
	 * 不支持预编译的增删改方法
	 */
	public static int excuteUpdate(String sql){
		
		return 0;
	}
	
	/*
	 * 支持预编译的查询方法
	 */
	public static List<Map<String,Object>> queryForList(String sql,int[] type,Object[] obj){
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		try {
			conn = getConnection();
			ps = conn.prepareStatement(sql);
			//循环遍历参数数组 并将数组中的值设置给预编译sql
			for (int i = 0; i < obj.length; i++) {
				switch (type[i]) {
				case Types.INTEGER:
					ps.setInt(i+1,Integer.parseInt(obj[i].toString()));
					break;
				case Types.VARCHAR:
					ps.setString(i+1,obj[i].toString());
					break;
				default:
					ps.setString(i+1,obj[i].toString());
				}
			}
			ResultSet rs = ps.executeQuery();
			list = rsToList(rs);
			close();
		
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return list;
	}
	/*
	 * 支持预编译的增删改方法    
	 */
	public static int excuteUpdate(String sql,int[] type,Object[] obj){
		
		return 0;
	}
	
	/*
	 * 不支持预编译的计数查询方法    
	 */
	public static int queryForCount(String sql){
		
		
		return 0;
	}
	
	/*
	 * 支持预编译的计数查询方法
	 */
	
	public static int queryForCount(String sql,int[] type,Object[] obj){
		
		
		return 0;
	}
	
	/*
	 * 将resultSet结果集转换为List
	 * @param rs    封装数据的resultSet
	 * @return  	数据转换后的List
	 */
	private static List<Map<String, Object>> rsToList(ResultSet rs) {
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		
		try {
			while(rs.next()){
				Map<String, Object>  map =  new HashMap<String,Object>();
				for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) {
					switch (rs.getMetaData().getColumnType(i)) {
					case Types.INTEGER:
						map.put(rs.getMetaData().getColumnName(i),rs.getInt(i));
						break;
					case Types.VARCHAR:
						map.put(rs.getMetaData().getColumnName(i),rs.getString(i));
						break;
					default:
						map.put(rs.getMetaData().getColumnName(i),rs.getObject(i));
					}
				}
				list.add(map);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return list;
	}

	/*
	 * 关闭Connection连接的方法
	 */
	public static void close(){
		if(conn!=null){
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}finally {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
					System.gc();
				}
			}
		}
	}
	
	
	public static void main(String[] args) {
		
		List<Map<String, Object>> list =  new ArrayList<Map<String, Object>>();
		//测试非预编译方法
//		String sql ="select * from people";
//		list = DbUtils.queryForList(sql);
//		for (Map<String, Object> map : list) {
//			System.out.println(map.get("name")+"---"+map.get("age"));
//		}
		//测试预编译对象
		String sql1 ="select * from people where age = ? and sex= ? and salary >?";
		int [] type = {Types.INTEGER,Types.VARCHAR,Types.FLOAT};
		Object[] obj = {20,"男",3500};
		list = DbUtils.queryForList(sql1,type,obj);
		for (Map<String, Object> map : list) {
			System.out.println(map.get("name")+"---"+map.get("age"));
		}
	}
}

注：这个没有写完

1
2
3
4
5
6
7
8
9
10
#driverUrl=com.mysql.jdbc.Driver
#url =jdbc:mysql://localhost:3306/test4?useUnicode=true&characterEncoding=utf8
#username=root
#password=root


driverUrl=oracle.jdbc.driver.OracleDriver
url =jdbc:oracle:thin:@192.168.42.43:1521:orcl
username=gao
password=gao