优化JDBC开发

一、元数据

元数据：数据库、表、列的定义信息

1、DataBaseMetaData对象

getURL()：返回一个String类对象，代表数据库的URL。

getUserName()：返回连接当前数据库管理系统的用户名。

getDatabaseProductName()：返回数据库的产品名称。

getDatabaseProductVersion()：返回数据库的版本号。

getDriverName()：返回驱动驱动程序的名称。

getDriverVersion()：返回驱动程序的版本号。

isReadOnly()：返回一个boolean值，指示数据库是否只允许读操作。

 /**
      * 获取数据库的元数据
      * @throws SQLException
      */
     @Test
     public void test1() throws SQLException{
         Connection con = JdbcUtils_DBCP.getConnection();

         //获取数据库的元数据
         DatabaseMetaData meta = con.getMetaData();
         //获取数据库的版本
         System.out.println(meta.getDatabaseMajorVersion());
         //获取数据库的产品名称
         System.out.println(meta.getDatabaseProductName());
         //获取数据库默认的隔离级别
         System.out.println(meta.getDefaultTransactionIsolation());

         /**
          * 结果:
          *     5
             MySQL
             2
          *
          */
     }

2、 ParameterMetaData对象

PreparedStatement . getParameterMetaData()

获得代表PreparedStatement元数据的ParameterMetaData对象。

Select * from user where name=? And password=?

　　　　ParameterMetaData对象

getParameterCount()

获得指定参数的个数

getParameterType(int param)

获得指定参数的sql类型

 /**
      * 获取参数元数据
      * @throws SQLException
      */
     @Test
     public void test2() throws SQLException{
         Connection con = JdbcUtils_DBCP.getConnection();
         String sql = "insert into account(name,money) values(?,?)";
         //预编译sql语句
         PreparedStatement ps = con.prepareStatement(sql);
         //获取参数元数据
         ParameterMetaData meta = ps.getParameterMetaData();

         //获取参数的个数  结果：2
         System.out.println(meta.getParameterCount());

         //获取参数的类型
         System.out.println(meta.getParameterType(1));
     }
     

3、ResultSetMetaData对象

ResultSet. getMetaData()

获得代表ResultSet对象元数据的ResultSetMetaData对象。

ResultSetMetaData对象

getColumnCount()

返回resultset对象的列数

getColumnName(int column)

获得指定列的名称

getColumnTypeName(int column)

获得指定列的类型

 /*
      * 获取结果集元数据
      */

     @Test
     public void test3() throws SQLException{
         Connection con = JdbcUtils_DBCP.getConnection();
         String sql = "select * from account";
         //预编译sql语句
         PreparedStatement ps = con.prepareStatement(sql);
         ResultSet rs = ps.executeQuery();

         //获取元数据
         ResultSetMetaData meta = rs.getMetaData();
         System.out.println(meta.getColumnCount());
         System.out.println(meta.getColumnName(1));
         System.out.println(meta.getColumnName(2));
         System.out.println(meta.getColumnName(3));

         //结果：id name money
     }

二、对JDBC进行优化

1、对增、删、改进行优化

所有实体的CUD操作代码基本相同，仅仅发送给数据库的SQL语句不同而已，因此可以把CUD操作的所有相同代码抽取到工具类的一个update方法中，并定义参数接收变化的SQL语句。

 //优化JDBC的增、删、改
         /**
          *
          * @param sql 接受参数
          * @param params 参数  替换掉sql语句的？号
          * @throws SQLException
          */
         public static void create_delete_update(String sql,Object params[]) throws SQLException{
             Connection con = null;
             PreparedStatement st = null;
             ResultSet result = null;

             try{
                 con = getConnection();
                 st = con.prepareStatement(sql);

                 //把sql的?号替换掉
                 for(int i=0;i<params.length;i++){

                     //因为不清楚表的列数据是什么类型，所以用Object
                     st.setObject(i+1,params[i]);
                 }

                 st.executeUpdate();

             }finally{
                 release(con, st, result);
             }
         }

2、对查找进行优化

     //优化sql查询
         public  static Object query(String sql,Object params[],ResultSetHandler handler) throws SQLException{
             Connection con = null;
             PreparedStatement st = null;
             ResultSet rs = null;
             try{
                 con = getConnection();
                 st = con.prepareStatement(sql);
                 //替代问号
                 for(int i=0;i<params.length;i++){
                     st.setObject(i+1, params[i]);
                 }

                 //执行
                 rs = st.executeQuery();

                 //由于不知道调用者怎么处理结果集，所有由调用者调用时传入一个处理器对象，调用处理器对象的处理方法
                 return handler.handler(rs);
             }finally{
                 release(con, st, rs);
             }
         }

 }

 //暴露接口
 interface ResultSetHandler{
     public Object handler(ResultSet rs);
 }

 //实现把结果封装到bean里面,适用于查找一条数据
 class BeanHandler implements ResultSetHandler{
     Class clazz;
     public BeanHandler(Class clazz){
         this.clazz  = clazz;
     }

     //处理方法，把数据封装到javabean
     public Object handler(ResultSet rs) {
         try {
             if(!rs.next()){
                 return null;
             }

             //创建封装结果的bean对象
             Object bean  = clazz.newInstance();

             //得到结果集数的元数据，已获取结果集的信息
             ResultSetMetaData meta = rs.getMetaData();

             //得到结果集的列数
             int count = meta.getColumnCount();

             //for循环赋值给bean对象
             for(int i=0;i<count;i++){
                 String name = meta.getColumnName(i+1);
                 Object value = rs.getObject(name);

                 //反射出bean上与列名相应的属性
                 Field f = bean.getClass().getDeclaredField(name);
                 //由于属性是私有的，要把属性设置成可见的
                 f.setAccessible(true);
                 //设置属性
                 f.set(bean, value);
             }

             return bean;
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 }

 //把结果封装到一个集合里面去
 class BeanListHandler implements ResultSetHandler{
     Class clazz;
     public BeanListHandler(Class clazz){
         this.clazz = clazz;
     }

     public Object handler(ResultSet rs){
         List list  = new ArrayList();
         try{
             while(rs.next()){
                 //创建bean对象
                 Object bean = clazz.newInstance();
                 ResultSetMetaData meta = rs.getMetaData();

                 //获取列数
                 int count = meta.getColumnCount();
                 for(int i=0;i<count;i++){
                     //列名
                     String name = meta.getColumnName(i+1);
                     Object value = rs.getObject(name);
                     Field f = bean.getClass().getDeclaredField(name);
                     f.setAccessible(true);
                     f.set(bean, value);
                 }
                 list.add(bean);
             }
         }catch(Exception e){
             throw new RuntimeException(e);
         }
         return list;
     }
 }

3、完整代码

 package com.utils;
 import java.io.InputStream;
 import java.lang.reflect.Field;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Properties;
 import javax.sql.DataSource;
 import org.apache.commons.dbcp.BasicDataSourceFactory;

 public class DButils {

     //数据库连接池
         private static DataSource ds = null;
         static{
             try{
                 //读取配置文件
                 InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
                 Properties prop = new Properties();
                 prop.load(in);
                 BasicDataSourceFactory factory = new BasicDataSourceFactory();
                 //创建连接池
                 ds = factory.createDataSource(prop);
             }catch(Exception e){
                 throw new ExceptionInInitializerError(e);
             }
         }

         //获取连接
         public static Connection getConnection() throws SQLException{

             return ds.getConnection();
         }

         //释放资源
         public static void release(Connection con,Statement st,ResultSet result){
             if(result!=null){
                 try {
                     result.close();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
                 result = null;
             }

             if(st!=null){
                 try {
                     st.close();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
                 st = null;
             }

             if(con!=null){
                 try {
                     con.close();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }

             }
         }

         //优化JDBC的增、删、改
         /**
          *
          * @param sql 接受参数
          * @param params 参数  替换掉sql语句的？号
          * @throws SQLException
          */
         public static void create_delete_update(String sql,Object params[]) throws SQLException{
             Connection con = null;
             PreparedStatement st = null;
             ResultSet result = null;

             try{
                 con = getConnection();
                 st = con.prepareStatement(sql);

                 //把sql的?号替换掉
                 for(int i=0;i<params.length;i++){

                     //因为不清楚表的列数据是什么类型，所以用Object
                     st.setObject(i+1,params[i]);
                 }

                 st.executeUpdate();

             }finally{
                 release(con, st, result);
             }
         }

         //优化sql查询
         public  static Object query(String sql,Object params[],ResultSetHandler handler) throws SQLException{
             Connection con = null;
             PreparedStatement st = null;
             ResultSet rs = null;
             try{
                 con = getConnection();
                 st = con.prepareStatement(sql);
                 //替代问号
                 for(int i=0;i<params.length;i++){
                     st.setObject(i+1, params[i]);
                 }

                 //执行
                 rs = st.executeQuery();

                 //由于不知道调用者怎么处理结果集，所有由调用者调用时传入一个处理器对象，调用处理器对象的处理方法
                 return handler.handler(rs);
             }finally{
                 release(con, st, rs);
             }
         }

 }

 //暴露接口
 interface ResultSetHandler{
     public Object handler(ResultSet rs);
 }

 //实现把结果封装到bean里面,适用于查找一条数据
 class BeanHandler implements ResultSetHandler{
     Class clazz;
     public BeanHandler(Class clazz){
         this.clazz  = clazz;
     }

     //处理方法，把数据封装到javabean
     public Object handler(ResultSet rs) {
         try {
             if(!rs.next()){
                 return null;
             }

             //创建封装结果的bean对象
             Object bean  = clazz.newInstance();

             //得到结果集数的元数据，已获取结果集的信息
             ResultSetMetaData meta = rs.getMetaData();

             //得到结果集的列数
             int count = meta.getColumnCount();

             //for循环赋值给bean对象
             for(int i=0;i<count;i++){
                 String name = meta.getColumnName(i+1);
                 Object value = rs.getObject(name);

                 //反射出bean上与列名相应的属性
                 Field f = bean.getClass().getDeclaredField(name);
                 //由于属性是私有的，要把属性设置成可见的
                 f.setAccessible(true);
                 //设置属性
                 f.set(bean, value);
             }

             return bean;
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 }

 //把结果封装到一个集合里面去
 class BeanListHandler implements ResultSetHandler{
     Class clazz;
     public BeanListHandler(Class clazz){
         this.clazz = clazz;
     }

     public Object handler(ResultSet rs){
         List list  = new ArrayList();
         try{
             while(rs.next()){
                 //创建bean对象
                 Object bean = clazz.newInstance();
                 ResultSetMetaData meta = rs.getMetaData();

                 //获取列数
                 int count = meta.getColumnCount();
                 for(int i=0;i<count;i++){
                     //列名
                     String name = meta.getColumnName(i+1);
                     Object value = rs.getObject(name);
                     Field f = bean.getClass().getDeclaredField(name);
                     f.setAccessible(true);
                     f.set(bean, value);
                 }
                 list.add(bean);
             }
         }catch(Exception e){
             throw new RuntimeException(e);
         }
         return list;
     }
 }

测试：

 package com.utils;

 import java.sql.SQLException;
 import java.util.Iterator;
 import java.util.List;

 import org.junit.Test;

 import com.domain.Account;

 public class Demo {

     //测试添加
     @Test
     public void testAdd() throws SQLException{
         Account a = new Account();
         a.setName("陈海宏");
         a.setMoney(30);
         add(a);
     }

     @Test
     //测试删除
     public void testDelete() throws SQLException{
         delete(1);
     }

     @Test
     //测试更改
     public void testUpdate() throws SQLException{
         Account a = new Account();
         a.setId(2);
         a.setName("王五");
         a.setMoney(30);
         update(a);
     }

     @Test
     //测试查找单项记录
     public void testFind() throws SQLException{
         Account a = find(7);
         System.out.println(a.getName());
     }

     //测试查找单记录
     @Test
     public void testGetAll() throws SQLException{
         List list = getAll();
         //对集合进行迭代
         Iterator it = list.iterator();
         while(it.hasNext()){
             Account a = (Account) it.next();
             System.out.println(a.getId()+"+"+a.getName()+"+"+a.getMoney());

         }
     }

     //添加
     public void add(Account a) throws SQLException{

         //准备sql语句
         String sql = "insert into account(name,money) values(?,?)";
         //替换？的参数数据
         Object params[] = {a.getName(),a.getMoney()};
         DButils.create_delete_update(sql, params);

     }

     //删除
     public void delete(int id) throws SQLException{

         //准备sql语句
         String sql = "delete from account where id=?";
         //替换？的参数数据
         Object params[] = {id};
         DButils.create_delete_update(sql, params);
     }

     //更新
     public void update(Account a) throws SQLException{
         String sql = "update account set name = ?,money = ? where id=?";
         Object params[] = {a.getName(),a.getMoney(),a.getId()};
         DButils.create_delete_update(sql, params);
     }

     //查找单项记录
     public Account find(int i) throws SQLException{
         String sql = "select * from account where id=?";
         Object params[] = {i};
         return (Account) DButils.query(sql, params,new BeanHandler(Account.class));
     }

     //查找所有记录
         public List getAll() throws SQLException{
             String sql = "select * from account";
             Object params[] = {};
             return (List) DButils.query(sql, params,new BeanListHandler(Account.class));
         }
 }