一、元数据
元数据：数据库、表、列的定义信息
1、DataBaseMetaData对象
getURL()：返回一个String类对象，代表数据库的URL。
getUserName()：返回连接当前数据库管理系统的用户名。
getDatabaseProductName()：返回数据库的产品名称。
getDatabaseProductVersion()：返回数据库的版本号。
getDriverName()：返回驱动驱动程序的名称。
getDriverVersion()：返回驱动程序的版本号。
isReadOnly()：返回一个boolean值，指示数据库是否只允许读操作。
1 /**
2 * 获取数据库的元数据 3 * @throws SQLException 4 */
5 @Test 6 public void test1() throws SQLException{ 7 Connection con = JdbcUtils_DBCP.getConnection(); 8
9 //获取数据库的元数据
10 DatabaseMetaData meta = con.getMetaData(); 11 //获取数据库的版本
12 System.out.println(meta.getDatabaseMajorVersion()); 13 //获取数据库的产品名称
14 System.out.println(meta.getDatabaseProductName()); 15 //获取数据库默认的隔离级别
16 System.out.println(meta.getDefaultTransactionIsolation()); 17
18 /**
19 * 结果: 20 * 5 21 MySQL 22 2 23 * 24 */
25 }
2、 ParameterMetaData对象
PreparedStatement . getParameterMetaData()
获得代表PreparedStatement元数据的ParameterMetaData对象。
Select * from user where name=? And password=?
ParameterMetaData对象
getParameterCount()
获得指定参数的个数
getParameterType(int param)
获得指定参数的sql类型
1 /**
2 * 获取参数元数据 3 * @throws SQLException 4 */
5 @Test 6 public void test2() throws SQLException{ 7 Connection con = JdbcUtils_DBCP.getConnection(); 8 String sql = "insert into account(name,money) values(?,?)"; 9 //预编译sql语句
10 PreparedStatement ps = con.prepareStatement(sql); 11 //获取参数元数据
12 ParameterMetaData meta = ps.getParameterMetaData(); 13
14 //获取参数的个数 结果：2
15 System.out.println(meta.getParameterCount()); 16
17 //获取参数的类型
18 System.out.println(meta.getParameterType(1)); 19 } 20
3、ResultSetMetaData对象
ResultSet. getMetaData()
获得代表ResultSet对象元数据的ResultSetMetaData对象。
ResultSetMetaData对象
getColumnCount()
返回resultset对象的列数
getColumnName(int column)
获得指定列的名称
getColumnTypeName(int column)
获得指定列的类型
1 /*
2 * 获取结果集元数据 3 */
4
5 @Test 6 public void test3() throws SQLException{ 7 Connection con = JdbcUtils_DBCP.getConnection(); 8 String sql = "select * from account"; 9 //预编译sql语句
10 PreparedStatement ps = con.prepareStatement(sql); 11 ResultSet rs = ps.executeQuery(); 12
13 //获取元数据
14 ResultSetMetaData meta = rs.getMetaData(); 15 System.out.println(meta.getColumnCount()); 16 System.out.println(meta.getColumnName(1)); 17 System.out.println(meta.getColumnName(2)); 18 System.out.println(meta.getColumnName(3)); 19
20 //结果：id name money
21 }
二、对JDBC进行优化
1、对增、删、改进行优化
所有实体的CUD操作代码基本相同，仅仅发送给数据库的SQL语句不同而已，因此可以把CUD操作的所有相同代码抽取到工具类的一个update方法中，并定义参数接收变化的SQL语句。
1 //优化JDBC的增、删、改
2 /**
3 * 4 * @param sql 接受参数 5 * @param params 参数 替换掉sql语句的？号 6 * @throws SQLException 7 */
8 public static void create_delete_update(String sql,Object params[]) throws SQLException{ 9 Connection con = null; 10 PreparedStatement st = null; 11 ResultSet result = null; 12
13 try{ 14 con = getConnection(); 15 st = con.prepareStatement(sql); 16
17 //把sql的?号替换掉
18 for(int i=0;i<params.length;i++){ 19
20 //因为不清楚表的列数据是什么类型，所以用Object
21 st.setObject(i+1,params[i]); 22 } 23
24 st.executeUpdate(); 25
26 }finally{ 27 release(con, st, result); 28 } 29 }
2、对查找进行优化
1 //优化sql查询
2 public static Object query(String sql,Object params[],ResultSetHandler handler) throws SQLException{ 3 Connection con = null; 4 PreparedStatement st = null; 5 ResultSet rs = null; 6 try{ 7 con = getConnection(); 8 st = con.prepareStatement(sql); 9 //替代问号
10 for(int i=0;i<params.length;i++){ 11 st.setObject(i+1, params[i]); 12 } 13
14 //执行
15 rs = st.executeQuery(); 16
17 //由于不知道调用者怎么处理结果集，所有由调用者调用时传入一个处理器对象，调用处理器对象的处理方法
18 return handler.handler(rs); 19 }finally{ 20 release(con, st, rs); 21 } 22 } 23
24 } 25
26
27 //暴露接口
28 interface ResultSetHandler{ 29 public Object handler(ResultSet rs); 30 } 31
32 //实现把结果封装到bean里面,适用于查找一条数据
33 class BeanHandler implements ResultSetHandler{ 34 Class clazz; 35 public BeanHandler(Class clazz){ 36 this.clazz = clazz; 37 } 38
39 //处理方法，把数据封装到javabean
40 public Object handler(ResultSet rs) { 41 try { 42 if(!rs.next()){ 43 return null; 44 } 45
46 //创建封装结果的bean对象
47 Object bean = clazz.newInstance(); 48
49 //得到结果集数的元数据，已获取结果集的信息
50 ResultSetMetaData meta = rs.getMetaData(); 51
52 //得到结果集的列数
53 int count = meta.getColumnCount(); 54
55 //for循环赋值给bean对象
56 for(int i=0;i<count;i++){ 57 String name = meta.getColumnName(i+1); 58 Object value = rs.getObject(name); 59
60 //反射出bean上与列名相应的属性
61 Field f = bean.getClass().getDeclaredField(name); 62 //由于属性是私有的，要把属性设置成可见的
63 f.setAccessible(true); 64 //设置属性
65 f.set(bean, value); 66 } 67
68 return bean; 69 } catch (Exception e) { 70 throw new RuntimeException(e); 71 } 72 } 73 } 74
75 //把结果封装到一个集合里面去
76 class BeanListHandler implements ResultSetHandler{ 77 Class clazz; 78 public BeanListHandler(Class clazz){ 79 this.clazz = clazz; 80 } 81
82 public Object handler(ResultSet rs){ 83 List list = new ArrayList(); 84 try{ 85 while(rs.next()){ 86 //创建bean对象
87 Object bean = clazz.newInstance(); 88 ResultSetMetaData meta = rs.getMetaData(); 89
90 //获取列数
91 int count = meta.getColumnCount(); 92 for(int i=0;i<count;i++){ 93 //列名
94 String name = meta.getColumnName(i+1); 95 Object value = rs.getObject(name); 96 Field f = bean.getClass().getDeclaredField(name); 97 f.setAccessible(true); 98 f.set(bean, value); 99 } 100 list.add(bean); 101 } 102 }catch(Exception e){ 103 throw new RuntimeException(e); 104 } 105 return list; 106 } 107 }
3、完整代码
1 package com.utils; 2 import java.io.InputStream; 3 import java.lang.reflect.Field; 4 import java.sql.Connection; 5 import java.sql.DriverManager; 6 import java.sql.PreparedStatement; 7 import java.sql.ResultSet; 8 import java.sql.ResultSetMetaData; 9 import java.sql.SQLException; 10 import java.sql.Statement; 11 import java.util.ArrayList; 12 import java.util.List; 13 import java.util.Properties; 14 import javax.sql.DataSource; 15 import org.apache.commons.dbcp.BasicDataSourceFactory; 16
17 public class DButils { 18
19 //数据库连接池
20 private static DataSource ds = null; 21 static{ 22 try{ 23 //读取配置文件
24 InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties"); 25 Properties prop = new Properties(); 26 prop.load(in); 27 BasicDataSourceFactory factory = new BasicDataSourceFactory(); 28 //创建连接池
29 ds = factory.createDataSource(prop); 30 }catch(Exception e){ 31 throw new ExceptionInInitializerError(e); 32 } 33 } 34
35
36 //获取连接
37 public static Connection getConnection() throws SQLException{ 38
39 return ds.getConnection(); 40 } 41
42 //释放资源
43 public static void release(Connection con,Statement st,ResultSet result){ 44 if(result!=null){ 45 try { 46 result.close(); 47 } catch (Exception e) { 48 e.printStackTrace(); 49 } 50 result = null; 51 } 52
53 if(st!=null){ 54 try { 55 st.close(); 56 } catch (Exception e) { 57 e.printStackTrace(); 58 } 59 st = null; 60 } 61
62 if(con!=null){ 63 try { 64 con.close(); 65 } catch (Exception e) { 66 e.printStackTrace(); 67 } 68
69 } 70 } 71
72
73 //优化JDBC的增、删、改
74 /**
75 * 76 * @param sql 接受参数 77 * @param params 参数 替换掉sql语句的？号 78 * @throws SQLException 79 */
80 public static void create_delete_update(String sql,Object params[]) throws SQLException{ 81 Connection con = null; 82 PreparedStatement st = null; 83 ResultSet result = null; 84
85 try{ 86 con = getConnection(); 87 st = con.prepareStatement(sql); 88
89 //把sql的?号替换掉
90 for(int i=0;i<params.length;i++){ 91
92 //因为不清楚表的列数据是什么类型，所以用Object
93 st.setObject(i+1,params[i]); 94 } 95
96 st.executeUpdate(); 97
98 }finally{ 99 release(con, st, result); 100 } 101 } 102
103
104 //优化sql查询
105 public static Object query(String sql,Object params[],ResultSetHandler handler) throws SQLException{ 106 Connection con = null; 107 PreparedStatement st = null; 108 ResultSet rs = null; 109 try{ 110 con = getConnection(); 111 st = con.prepareStatement(sql); 112 //替代问号
113 for(int i=0;i<params.length;i++){ 114 st.setObject(i+1, params[i]); 115 } 116
117 //执行
118 rs = st.executeQuery(); 119
120 //由于不知道调用者怎么处理结果集，所有由调用者调用时传入一个处理器对象，调用处理器对象的处理方法
121 return handler.handler(rs); 122 }finally{ 123 release(con, st, rs); 124 } 125 } 126
127 } 128
129
130 //暴露接口
131 interface ResultSetHandler{ 132 public Object handler(ResultSet rs); 133 } 134
135 //实现把结果封装到bean里面,适用于查找一条数据
136 class BeanHandler implements ResultSetHandler{ 137 Class clazz; 138 public BeanHandler(Class clazz){ 139 this.clazz = clazz; 140 } 141
142 //处理方法，把数据封装到javabean
143 public Object handler(ResultSet rs) { 144 try { 145 if(!rs.next()){ 146 return null; 147 } 148
149 //创建封装结果的bean对象
150 Object bean = clazz.newInstance(); 151
152 //得到结果集数的元数据，已获取结果集的信息
153 ResultSetMetaData meta = rs.getMetaData(); 154
155 //得到结果集的列数
156 int count = meta.getColumnCount(); 157
158 //for循环赋值给bean对象
159 for(int i=0;i<count;i++){ 160 String name = meta.getColumnName(i+1); 161 Object value = rs.getObject(name); 162
163 //反射出bean上与列名相应的属性
164 Field f = bean.getClass().getDeclaredField(name); 165 //由于属性是私有的，要把属性设置成可见的
166 f.setAccessible(true); 167 //设置属性
168 f.set(bean, value); 169 } 170
171 return bean; 172 } catch (Exception e) { 173 throw new RuntimeException(e); 174 } 175 } 176 } 177
178 //把结果封装到一个集合里面去
179 class BeanListHandler implements ResultSetHandler{ 180 Class clazz; 181 public BeanListHandler(Class clazz){ 182 this.clazz = clazz; 183 } 184
185 public Object handler(ResultSet rs){ 186 List list = new ArrayList(); 187 try{ 188 while(rs.next()){ 189 //创建bean对象
190 Object bean = clazz.newInstance(); 191 ResultSetMetaData meta = rs.getMetaData(); 192
193 //获取列数
194 int count = meta.getColumnCount(); 195 for(int i=0;i<count;i++){ 196 //列名
197 String name = meta.getColumnName(i+1); 198 Object value = rs.getObject(name); 199 Field f = bean.getClass().getDeclaredField(name); 200 f.setAccessible(true); 201 f.set(bean, value); 202 } 203 list.add(bean); 204 } 205 }catch(Exception e){ 206 throw new RuntimeException(e); 207 } 208 return list; 209 } 210 } 211
212
213
214
215
测试：
1 package com.utils; 2
3 import java.sql.SQLException; 4 import java.util.Iterator; 5 import java.util.List; 6
7 import org.junit.Test; 8
9 import com.domain.Account; 10
11 public class Demo { 12
13 //测试添加
14 @Test 15 public void testAdd() throws SQLException{ 16 Account a = new Account(); 17 a.setName("陈海宏"); 18 a.setMoney(30); 19 add(a); 20 } 21
22 @Test 23 //测试删除
24 public void testDelete() throws SQLException{ 25 delete(1); 26 } 27
28 @Test 29 //测试更改
30 public void testUpdate() throws SQLException{ 31 Account a = new Account(); 32 a.setId(2); 33 a.setName("王五"); 34 a.setMoney(30); 35 update(a); 36 } 37
38 @Test 39 //测试查找单项记录
40 public void testFind() throws SQLException{ 41 Account a = find(7); 42 System.out.println(a.getName()); 43 } 44
45
46
47
48 //测试查找单记录
49 @Test 50 public void testGetAll() throws SQLException{ 51 List list = getAll(); 52 //对集合进行迭代
53 Iterator it = list.iterator(); 54 while(it.hasNext()){ 55 Account a = (Account) it.next(); 56 System.out.println(a.getId()+"+"+a.getName()+"+"+a.getMoney()); 57
58 } 59 } 60
61
62
63 //添加
64 public void add(Account a) throws SQLException{ 65
66 //准备sql语句
67 String sql = "insert into account(name,money) values(?,?)"; 68 //替换？的参数数据
69 Object params[] = {a.getName(),a.getMoney()}; 70 DButils.create_delete_update(sql, params); 71
72 } 73
74 //删除
75 public void delete(int id) throws SQLException{ 76
77 //准备sql语句
78 String sql = "delete from account where id=?"; 79 //替换？的参数数据
80 Object params[] = {id}; 81 DButils.create_delete_update(sql, params); 82 } 83
84 //更新
85 public void update(Account a) throws SQLException{ 86 String sql = "update account set name = ?,money = ? where id=?"; 87 Object params[] = {a.getName(),a.getMoney(),a.getId()}; 88 DButils.create_delete_update(sql, params); 89 } 90
91 //查找单项记录
92 public Account find(int i) throws SQLException{ 93 String sql = "select * from account where id=?"; 94 Object params[] = {i}; 95 return (Account) DButils.query(sql, params,new BeanHandler(Account.class)); 96 } 97
98 //查找所有记录
99 public List getAll() throws SQLException{ 100 String sql = "select * from account"; 101 Object params[] = {}; 102 return (List) DButils.query(sql, params,new BeanListHandler(Account.class)); 103 } 104 }