JDBCUtils工具类的基础学习笔记

注：以下整理笔记来自自己的公众号，适合初学者一起探讨，我也是初学者！

创建一个实体类：

package com.zx.bean;

public class User {
  private int id;
  private String name;
  private String password;
  private String tel;
  private String email;
  
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getPassword() {
    return password;
  }
  public void setPassword(String password) {
    this.password = password;
  }
  public String getTel() {
    return tel;
  }
  public void setTel(String tel) {
    this.tel = tel;
  }
  public String getEmail() {
    return email;
  }
  public void setEmail(String email) {
    this.email = email;
  }
  @Override
  public String toString() {
    return "User [id=" + id + ", name=" + name + ", password=" + password + ", tel=" + tel + ", email=" + email
        + "]";
  }
}

1.初步使用jdbcutils，简单使用，直接在需要的地方使用

package com.zx.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;

import com.zx.bean.User;

public class DataSources {
  private static String driver="com.mysql.jdbc.Driver";
  private static String URL="jdbc:mysql://localhost:3306/data_gk";
  private static String USER="root";
  private static String PASSWORD="12345";
  private Connection connection=null;
  private PreparedStatement preparedStatement=null;
  private ResultSet resultSet=null;
  public static void main(String[] args) {
    new DataSources();

  }
  public DataSources() {
    this.query();
    this.insert();
    this.update();
    this.delete();
  }
  //查询数据
  public void query(){  
    try {
      //注册驱动
      Class.forName(driver);
      //连接数据库
      connection=DriverManager.getConnection(URL,USER,PASSWORD);
      System.out.println("恭喜！数据库连接成功！");
      
      String sql="select * from user";
      //使用preparedStatement防止SQL注入
      preparedStatement=connection.prepareStatement(sql);
      //得到查询结果，结果是一个数组
      resultSet=preparedStatement.executeQuery();
      //将结果放进集合中，方便读取
      ArrayList<User> list=new ArrayList<User>();
      while(resultSet.next()) {
        //将结果封装到user对象中
        User user=new User();
        user.setId(resultSet.getInt("id"));
        user.setName(resultSet.getString("name"));
        user.setPassword(resultSet.getString("password"));
        user.setTel(resultSet.getString("tel"));
        user.setEmail(resultSet.getString("email"));
        list.add(user);
      }
      //使用迭代器输出结果
      Iterator it=list.iterator();
      while(it.hasNext()) {
        System.out.println(it.next().toString());
      }
    } catch (ClassNotFoundException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }catch (SQLException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }finally {
      //关闭数据资源
      try {
        resultSet.close();
      }catch (SQLException e) {
        System.out.println("resultSet资源关闭失败！");
        e.printStackTrace();
      }
      try {
        preparedStatement.close();
      }catch (SQLException e) {
        System.out.println("preparedStatement资源关闭失败！");
        e.printStackTrace();
      }
      try {
        connection.close();
      }catch (SQLException e) {
        System.out.println("connection资源关闭失败！");
        e.printStackTrace();
      }
      System.out.println("数据库资源已关闭！");
      
    }
  }
  
  //添加数据
  public void insert(){  
    try {
      //注册驱动
      Class.forName(driver);
      //连接数据库
      connection=DriverManager.getConnection(URL,USER,PASSWORD);
      System.out.println("恭喜！数据库连接成功！");
      
      String sql="insert into user(name,password,tel,email) values('tom','12345','12345678900','[email protected]')";
      //使用preparedStatement防止SQL注入
      preparedStatement=connection.prepareStatement(sql);
      //返回添加结果，结果是一个整数
      int row =preparedStatement.executeUpdate();
      if(row>0) {
        System.out.println("数据添加成功！");
      }else {
        System.out.println("数据添加失败！");
      }
    } catch (ClassNotFoundException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }catch (SQLException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }finally {
      //关闭数据资源
      try {
        preparedStatement.close();
      }catch (SQLException e) {
        System.out.println("preparedStatement资源关闭失败！");
        e.printStackTrace();
      }
      try {
        connection.close();
      }catch (SQLException e) {
        System.out.println("connection资源关闭失败！");
        e.printStackTrace();
      }
      System.out.println("数据库资源已关闭！");
      
    }
  }
  
  //修改数据
  public void update(){  
    try {
      //注册驱动
      Class.forName(driver);
      //连接数据库
      connection=DriverManager.getConnection(URL,USER,PASSWORD);
      System.out.println("恭喜！数据库连接成功！");
      
      String sql="update user set name='lucy',password='55555' where id=3";
      //使用preparedStatement防止SQL注入
      preparedStatement=connection.prepareStatement(sql);
      //返回修改结果，结果是一个整数
      int row =preparedStatement.executeUpdate();
      if(row>0) {
        System.out.println("数据修改成功！");
      }else {
        System.out.println("数据修改失败！");
      }
    } catch (ClassNotFoundException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }catch (SQLException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }finally {
      //关闭数据资源
      try {
        preparedStatement.close();
      }catch (SQLException e) {
        System.out.println("preparedStatement资源关闭失败！");
        e.printStackTrace();
      }
      try {
        connection.close();
      }catch (SQLException e) {
        System.out.println("connection资源关闭失败！");
        e.printStackTrace();
      }
      System.out.println("数据库资源已关闭！");
      
    }
  }
  
  //删除数据
  public void delete(){  
    try {
      //注册驱动
      Class.forName(driver);
      //连接数据库
      connection=DriverManager.getConnection(URL,USER,PASSWORD);
      System.out.println("恭喜！数据库连接成功！");
      
      String sql="delete from user where id=3";
      //使用preparedStatement防止SQL注入
      preparedStatement=connection.prepareStatement(sql);
      //返回删除结果，结果是一个整数
      int row =preparedStatement.executeUpdate();
      if(row>0) {
        System.out.println("数据删除成功！");
      }else {
        System.out.println("数据删除失败！");
      }
    } catch (ClassNotFoundException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }catch (SQLException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }finally {
      //关闭数据资源
      try {
        preparedStatement.close();
      }catch (SQLException e) {
        System.out.println("preparedStatement资源关闭失败！");
        e.printStackTrace();
      }
      try {
        connection.close();
      }catch (SQLException e) {
        System.out.println("connection资源关闭失败！");
        e.printStackTrace();
      }
      System.out.println("数据库资源已关闭！");
      
    }
  }
}

2.第2版：创建工具类：把相同部分抽取优化

package com.zx.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;

import com.zx.bean.User;

public class DataSources {
  private static String driver="com.mysql.jdbc.Driver";
  private static String URL="jdbc:mysql://localhost:3306/data_gk";
  private static String USER="root";
  private static String PASSWORD="12345";
  private Connection connection=null;
  private PreparedStatement preparedStatement=null;
  private ResultSet resultSet=null;
  private String sql="";
  public void getConnection(){
    try {
      //注册驱动
      Class.forName(driver);
      //连接数据库
      connection=DriverManager.getConnection(URL,USER,PASSWORD);
      System.out.println("恭喜！数据库连接成功！");
    } catch (ClassNotFoundException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    } catch (SQLException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }
    
  }
  public static void main(String[] args) {
    new DataSources();

  }
  public DataSources() {
    this.query();
    sql="insert into user(name,password,tel,email) values('tom','12345','12345678900','[email protected]')";
    this.update(sql,"添加");
    sql="update user set name='lucy',password='55555' where id=5";
    this.update(sql,"修改");
    sql="delete from user where id=5";
    this.update(sql,"删除");
  }
  //查询数据
  public void query(){  
    try {
      this.getConnection();
      sql="select * from user";
      //使用preparedStatement防止SQL注入
      preparedStatement=connection.prepareStatement(sql);
      //得到查询结果，结果是一个数组
      resultSet=preparedStatement.executeQuery();
      //将结果放进集合中，方便读取
      ArrayList<User> list=new ArrayList<User>();
      while(resultSet.next()) {
        //将结果封装到user对象中
        User user=new User();
        user.setId(resultSet.getInt("id"));
        user.setName(resultSet.getString("name"));
        user.setPassword(resultSet.getString("password"));
        user.setTel(resultSet.getString("tel"));
        user.setEmail(resultSet.getString("email"));
        list.add(user);
      }
      //使用迭代器输出结果
      Iterator it=list.iterator();
      while(it.hasNext()) {
        System.out.println(it.next().toString());
      }
    }catch (SQLException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }finally {
      //关闭数据资源
      this.close(connection, preparedStatement, resultSet);  
    }
  }
  
  //添加、修改、删除数据
  public void update(String sql,String action){  
    try {
      this.getConnection();
      //使用preparedStatement防止SQL注入
      preparedStatement=connection.prepareStatement(sql);
      //返回添加结果，结果是一个整数
      int row =preparedStatement.executeUpdate();
      if(row>0) {
        System.out.println("数据"+action+"成功！");
      }else {
        System.out.println("数据"+action+"失败！");
      }
    }catch (SQLException e) {
      System.out.println("数据"+action+"失败！");
      e.printStackTrace();
    }finally {
      //关闭数据资源
      this.close(connection, preparedStatement, resultSet);
    }
  }
  
  public static void close(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet) {
    if(connection !=null) {
      try {
        connection.close();
      }catch (SQLException e) {
        System.out.println("connection资源关闭失败！");
        e.printStackTrace();
      }
    }
    
    if(preparedStatement !=null) {
      try {
        preparedStatement.close();
      }catch (SQLException e) {
        System.out.println("preparedStatement资源关闭失败！");
        e.printStackTrace();
      }
    }
    
    if(resultSet !=null) {
      try {
        resultSet.close();
      }catch (SQLException e) {
        System.out.println("resultSet资源关闭失败！");
        e.printStackTrace();
      }
    }
    System.out.println("数据库资源已关闭！");
  }

}

演示示例：

3.第3版

//db.properties文档
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/data_gk?useSSL=true
usrname=root
password=12345

package com.zx.utils;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
//连接数据库
public class DataSources {
  private static String driver;
  private static String URL;
  private static String USER;
  private static String PASSWORD;

  static {  
    try {
      ClassLoader classLoader=DataSources.class.getClassLoader();
      //URL resources=classLoader.getResource ("db.properties");
      InputStream resources=classLoader.getResourceAsStream("db.properties");
      Properties properties=new Properties();
      properties.load(resources);
      //properties.load (new FileReader (resources.getPath ()));
      driver=properties.getProperty("driver");
      URL=properties.getProperty("url");
      USER=properties.getProperty("usrname");
      System.out.println(USER);
      PASSWORD=properties.getProperty("password");
    } catch (IOException e) {
      e.printStackTrace();
    }
    
  }
  
  public Connection getConnection(){
    Connection con=null;
    try {
      //注册驱动
      Class.forName(driver);
      //连接数据库
      con=DriverManager.getConnection(URL,USER,PASSWORD);
    } catch (ClassNotFoundException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    } catch (SQLException e) {
      System.out.println("数据库连接失败！");
      e.printStackTrace();
    }
    return con;  
  }
  
  public DataSources() {}
}

package com.zx.utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

import com.zx.bean.User;

//数据库处理
public class QueryRunnable {
  DataSources dataSources;
  public QueryRunnable(DataSources dataSources) {
    this.dataSources=dataSources;
  }
  //查询数据,将来使用泛型，这样就可以处理各种类了
  public ArrayList<User> query(String sql){
    ArrayList<User> list=new ArrayList<User>();
    try {
      Connection con=dataSources.getConnection();
      PreparedStatement preparedStatement=con.prepareStatement(sql);
      ResultSet resultSet=preparedStatement.executeQuery();
      while(resultSet.next()) {
        //将结果封装到user对象中
        User user=new User();
        user.setId(resultSet.getInt("id"));
        user.setName(resultSet.getString("name"));
        user.setPassword(resultSet.getString("password"));
        user.setTel(resultSet.getString("tel"));
        user.setEmail(resultSet.getString("email"));
        list.add(user);
      }
      //关闭资源
      resultSet.close();
      preparedStatement.close();
      con.close();
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return list;
  }
  
  //添加、修改、删除数据
  public int update(String sql) {
    int row=0;
    try {
      Connection con=dataSources.getConnection();
      //使用preparedStatement防止SQL注入
      PreparedStatement preparedStatement=con.prepareStatement(sql);
      //返回添加结果，结果是一个整数
      row =preparedStatement.executeUpdate();
      //关闭资源
      preparedStatement.close();
      con.close();
    }catch (SQLException e) {
      e.printStackTrace();
    }
    return row;  
  }
}

package com.zx.utils;

import java.util.ArrayList;
import java.util.Iterator;
import com.zx.bean.User;
//测试代码
public class Test {
  private String sql = "";

  public static void main(String[] args) {
    new Test();
  }

  public Test() {
    this.query();
    sql = "insert into user(name,password,tel,email) values('tom','12345','12345678900','[email protected]')";
    this.update(sql, "添加");
    sql = "update user set name='lucy',password='55555' where id=4";
    this.update(sql, "修改");
    sql = "delete from user where id=7";
    this.update(sql, "删除");
  }

  // 查询数据
  public void query() {
    sql = "select * from user";
    DataSources dataSources = new DataSources();
    QueryRunnable queryRunnable = new QueryRunnable(dataSources);
    ArrayList<User> list = queryRunnable.query(sql);
    // 使用迭代器输出结果
    Iterator it = list.iterator();
    while (it.hasNext()) {
      System.out.println(it.next().toString());
    }

  }

  // 添加、修改、删除数据
  public void update(String sql, String action) {
    DataSources dataSources = new DataSources();
    QueryRunnable queryRunnable = new QueryRunnable(dataSources);
    int row = queryRunnable.update(sql);
    if (row > 0) {
      System.out.println("数据" + action + "成功！");
    } else {
      System.out.println("数据" + action + "失败！");
    }
  }
}

演示示例：

4.第4版

package com.zx.utils;

import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

//数据库处理
public class QueryRunnable {
  DataSources dataSources;
  public QueryRunnable(DataSources dataSources) {
    this.dataSources=dataSources;
  }
  //查询数据,将来使用泛型，这样就可以处理各种类了
  public ArrayList query(String sql,Generics generics){
    ArrayList list=new ArrayList();
    try {
      Connection con=dataSources.getConnection();
      PreparedStatement preparedStatement=con.prepareStatement(sql);
      ResultSet resultSet=preparedStatement.executeQuery();
      while(resultSet.next()) {
        //需要set方法，属性类型，属性名称
        list.add(generics.reflectMethod(resultSet));
      }
      //关闭资源
      resultSet.close();
      preparedStatement.close();
      con.close();
    } catch (SQLException e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return list;
  }
  
  //添加、修改、删除数据
  public int update(String sql) {
    int row=0;
    try {
      Connection con=dataSources.getConnection();
      //使用preparedStatement防止SQL注入
      PreparedStatement preparedStatement=con.prepareStatement(sql);
      //返回添加结果，结果是一个整数
      row =preparedStatement.executeUpdate();
      //关闭资源
      preparedStatement.close();
      con.close();
    }catch (SQLException e) {
      e.printStackTrace();
    }
    return row;  
  }
}

class Generics<T>{
  Class obj;
  public Generics(Class obj) throws Exception {
    this.obj=obj;//获得类名  

  }
  //此方法不好之处是需要把sql中所有的基本类型都罗列一遍，而且很多方法是不确定的
  public T reflectMethod(ResultSet resultSet) throws Exception {
    T t=(T) obj.newInstance();//实例化对象
    Method[] mt=obj.getDeclaredMethods();//获取本类所有的方法
    for(Method e:mt) {
      if(e.getReturnType().equals(Void.TYPE)) {//获得所有set的方法
        Method met=obj.getDeclaredMethod(e.getName(), e.getParameterTypes()[0]);//获取指定类的方法
        String str=this.getMethodParameterName(e.getName());
        met.invoke(t, resultSet.getObject(str, e.getParameterTypes()[0]));//利用泛型处理resultSet的获取值
      }
      
    }
    return t;
  }
  public String getMethodParameterName(String ss) {
    return ss.substring(3,ss.length()).substring(0,1).toLowerCase()+ss.substring(4,ss.length());
    
  }
}

5.目前学习到的位置：

（1）继续优化

package com.gk.utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

//数据库处理
public class QueryRunner {
  DataSources dataSources;
  public QueryRunner(DataSources dataSources) {
    this.dataSources=dataSources;
  }
  //查询数据,将来使用泛型，这样就可以处理各种类了
  public ArrayList query(String sql,Generics generics,Object...params){
    ArrayList list=new ArrayList();
    try {
      Connection con=dataSources.getConnection();
      PreparedStatement preparedStatement=con.prepareStatement(sql);
      //使用不确定参数，解决参数类型和参数个数未定的问题
      for(int i=0;i<params.length;i++) {
        preparedStatement.setObject((i+1), params[i]);
      }
      ResultSet resultSet=preparedStatement.executeQuery();
      while(resultSet.next()) {
        //需要set方法，属性类型，属性名称
        list.add(generics.reflectMethod(resultSet));
      }
      //关闭资源
      resultSet.close();
      preparedStatement.close();
      con.close();
    } catch (SQLException e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return list;
  }

  //添加、修改、删除数据
  public int update(String sql,Object...params) {
    int row=0;
    try {
      Connection con=dataSources.getConnection();
      //使用preparedStatement防止SQL注入
      PreparedStatement preparedStatement=con.prepareStatement(sql);
      //使用不确定参数，解决参数类型和参数个数未定的问题
      for(int i=0;i<params.length;i++) {
        preparedStatement.setObject((i+1), params[i]);
      }
      //返回添加结果，结果是一个整数
      row =preparedStatement.executeUpdate();
      //关闭资源
      preparedStatement.close();
      con.close();
    }catch (SQLException e) {
      e.printStackTrace();
    }
    return row;
  }
}

（2）创建一个实验类，处理从前端收到的提交数据

package com.gk.utils;

import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
//处理前端所获参数及其值的工具类
public class BeanUtils{

  public static void populate(Object obj,Map<String,String[]> parameterMap) throws Exception {
    //根据得到的参数列表，对obj的所有属性的set方法进行赋值
    //使用反射获取所有set方法
    Class cls=obj.getClass ();//得到类名
    Method[] mt=cls.getDeclaredMethods();//获取本类所有的方法

    Set<String> keySet=parameterMap.keySet();//获取键的集合
    Iterator<String> it=keySet.iterator();//使用迭代器读取
    for(Method e:mt) {
      //用下面这个方法，前提如下：对象封装类的void方法只有set方法
      if(e.getReturnType().equals(Void.TYPE)) {
        Method met=cls.getDeclaredMethod(e.getName(), e.getParameterTypes()[0]);//获取指定类的方法
        String str=getMethodParameterName(e.getName());//获取set方法参数名
        while(it.hasNext()) {
          String key=it.next();//得到属性名
          String[] value=parameterMap.get(key);
          if (key.equals (str)) {
            met.invoke(obj,value[0] );//指定方法赋值，如果不是String类型？
            break;
          }
        }
      }
    }

//    //读取map集合所有元素的三种方法
//    /*方法1：通过keyset方法获取map中所有的键所在的set集合，再通过set的迭代器获取到每一个键
//     *   再对每一个键通过map集合的get方法获取其对应的值
//     */
//    Set<String> keySet=parameterMap.keySet();
//    Iterator<String> it=keySet.iterator();
//    while(it.hasNext()) {
//      String key=it.next();
//      String[] value=parameterMap.get(key);
//      System.out.println(key+":"+value[0]);
//    }

//    /*方法2：通过map转成set就可以迭代，找到另一个方法，entrySet
//     * 该方法将键和值得映射关系作为对象存储到set集合中，而这个映射关系的类型就是map.entry类型
//     */
//    Set<Map.Entry<String,String[]>> entrySet=parameterMap.entrySet();
//    Iterator<Map.Entry<String,String[]>> it1=entrySet.iterator();
//    while(it1.hasNext()) {
//      Map.Entry<String,String[]> me=it1.next();
//      String key1=me.getKey();
//      String[] value1=me.getValue();
//      System.out.println(key1+":"+value1[0]);
//    }
//
//    //取出map的values()方法取出其中所有的值，然后全部打印出来
//    Collection<String[]> values=parameterMap.values();
//
//    Iterator<String[]> it2=values.iterator();
//    while(it2.hasNext()) {
//      System.out.println(it2.next()[0]);
//    }
  }
  public static String getMethodParameterName(String ss) {
    return ss.substring(3,ss.length()).substring(0,1).toLowerCase()+ss.substring(4,ss.length());
  }

}