JDBC工具类：JDBCUtils

目录

• 1. 目的
• 2. 步骤
• 3. 简化后的代码
• 4. 额外的功能：将ResultSet结果映射到定义的Bean中

1. 目的

  每次使用JDBC的时候都要书写冗长的代码段，不符合复用的理念，于是要单独写一个类，将通用的JDBC操作写到一个类中，便于重复使用和精简代码。

2. 步骤

1. 注册驱动并获取连接
   1. 创建链接配置文件jdbc.properties，在resource资源路径下，要更换别的连接时，只需修改配置文件即可，无需修改类文件和重新编译。

      driver=数据库驱动路径
      url=url连接字符串
      user=用户名
      password=密码
      

   2. 然后就需要将配置文件中键值对中的值取出，并注册了驱动。因为驱动和取出配置文件只需要一次就可以，所以就写入到静态代码块中，在程序运行的开始就处理好了，无需以后再冗余执行。

      // 定义静态变量，使用静态代码获取配置文件的值
      private static String url;
      private static String user;
      private static String password;
      private static String driver;
      // 使用静态代码注册驱动并给静态变量赋值
      static{
          try {
              // 创建Properties集合类
              Properties pro = new Properties();
              // 获取src路径下文件，使用ClassLoader类加载器
              ClassLoader classLoader = JDBCUtils.class.getClassLoader();
              // URL定位了文件的绝对路径
              URL res = classLoader.getResource("jdbc.properties");
              // 获取字符串路径
              String path = res.getPath();
              // 读取文件
              pro.load(new FileReader(path));
              // 给静态变量赋值
              url = pro.getProperty("url");
              user = pro.getProperty("user");
              password = pro.getProperty("password");
              driver = pro.getProperty("driver");
              // 注册驱动
              Class.forName(driver);
          } catch (IOException e) {
              e.printStackTrace();
          } catch (ClassNotFoundException e) {
              e.printStackTrace();
          }
      }
      

   3. 获取连接

      public static Connection getConnection() throws SQLException {
          return DriverManager.getConnection(url, user, password);
      }
      

2. 释放资源

   /**
    * 释放资源
    *
    * @Param [stmt 执行sql的对象, conn 数据库连接对象]
    **/
   public static void close(Statement stmt, Connection conn){
       if(stmt != null){
           try {
               stmt.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
       if(conn != null){
           try {
               conn.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }
   
   /**
    * 释放资源Pro版
    *
    * @Param [rs 结果集对象, stmt 执行sql的对象, conn 数据库连接对象]
    **/
   public static void close(ResultSet rs, Statement stmt, Connection conn){
       if(rs != null){
           try {
               rs.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
       if(stmt != null){
           try {
               stmt.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
       if(conn != null){
           try {
               conn.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }
   

3. 简化后的代码

Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
　　conn = JDBCUtils.getConnection();
　　String sql = "SQL语句";
　　stmt = conn.createStatement();
　　rs = stmt.executeQuery(sql);
} catch (SQLException e) {
　　e.printStackTrace();
} finally {
　　JDBCUtils.close(rs, stmt, conn);
}

4. 额外的功能：将ResultSet结果映射到定义的Bean中

将从数据库获取的数据自动映射到定义的Bean中，在进行数据获取就变得容易多了，这个也可以封装成JDBCUtil的一个工具方法。需要事先导入 javax.persistence.jar 和 commons-beanutils.jar 依赖才可以使用。

import org.apache.commons.beanutils.BeanUtils;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;

public class JDBCUtil<T> {
    public List<T> resultSetToObj(ResultSet rs, Class clazz) {
        List<T> outputList = null;
        try {
            if (rs != null) {
                if (clazz.isAnnotationPresent(Entity.class)) {
                    ResultSetMetaData rsmd = rs.getMetaData();
                    Field[] fields = clazz.getDeclaredFields();
                    while (rs.next()) {
                        T bean = (T) clazz.newInstance();
                        for (int _iterator = 0; _iterator < rsmd.getColumnCount(); _iterator++) {
                            String columnName = rsmd.getColumnName(_iterator + 1);
                            Object columnValue = rs.getObject(_iterator + 1);
                            for (Field field : fields) {
                                if (field.isAnnotationPresent(Column.class)) {
                                    Column column = field.getAnnotation(Column.class);
                                    if (column.name().equalsIgnoreCase(columnName) && columnValue != null) {
                                        BeanUtils.setProperty(bean, field.getName(), columnValue);
                                        break;
                                    }
                                }
                            }
                        }
                        if (outputList == null) {
                            outputList = new ArrayList<T>();
                        }
                        outputList.add(bean);
                    }
                }
            } else {
                return null;
            }
        } catch (IllegaAccessException | InstantiationException | InvocationTargetException | SQLException e) {
            e.printStackTrace();
        }
        return outputList;
    }
}

然后是定义Bean：

import javax.persistence.Column;
import javax.persistence.Entity;

@Entity
public class PersonEntity {
    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private Integer age;

    // TODO Getter and Setter ...
}

最后是使用(外层的JDBC操作就不写了)：

// ResultSet rs = PreparedStatement.executeQuery();
JDBCUtil<PersonEntity> util = new JDBCUtil<>();
List<PersonEntity> list = util.resultSetToObj(rs, PersonEntity.class);