JAVA:手写JDBC工具类mysql版

Properties配置文件 

#jdbc链接数据库地址

URL=jdbc:mysql://127.0.0.1:3306/{需要链接的数据库名称}?useUnicode=true&acterEncodeing=utf8
#数据库账号
USER =root
#数据库密码
PASSWORD=root
#数据库驱动类
DERVER=com.mysql.jdbc.Driver

jdbc:mysql ：需要链接的数据库

127.0.0.1：数据库所在的主机地址

3306：数据库的监听端口

DERVER=com.mysql.jdbc.Driver 如果是新版的mysql jdbc jar包则驱动类地址有可能是com.mysql.cj.jdbc.Driver

JDBC 工具JAVA源码：

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 * @author Admin
 * Version 1.0
 */

public class JDBCTool {
    //连接地址
    private static final String URL;
    //    账号
    private static final String USER;
    //    密码
    private static final String PASSWORD;
    //    驱动路径
    private static final String DERVER;

    private static Connection connection;
    private PreparedStatement preparedStatement;
    private ResultSet resultSet;

    static {

//        得到properties对象加载配置文件
        Properties properties = new Properties();
        InputStream resourceAsStream = JDBCTool.class.getClassLoader().getResourceAsStream("jdbc.properties");
        // jdbc.properties  该配置文件名根据自己写的名字改 配置文件需放在resources文件夹下
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
             e.printStackTrace();
        }
        URL = properties.getProperty("URL");
        USER = properties.getProperty("USER");
        PASSWORD = properties.getProperty("PASSWORD");
        DERVER = properties.getProperty("DERVER");
        //加载mysql的驱动
        try {
            Class.forName(DERVER);

        } catch (ClassNotFoundException e) {
             e.printStackTrace();
        }
    }


    private static void open() {
        try {
            logger.debug("数据库地址:" + URL);
            logger.debug("数据库账号:" + USER);
            logger.debug("数据库密码:" + PASSWORD);
            connection = DriverManager.getConnection(URL, USER, PASSWORD);
            
//         关闭事务自动提交
            connection.setAutoCommit(false);
           
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * DML重载
     *        该方法可以在用来插入数据后获取当前数据自动增长的主键id
                 并且将该id做围返回值返回
     * @param sql        单条Sql操作
     * @param parameters sql操作参数
     * @return 返回主键ID  ERROR return -1
     */
    public int insert_returnId(String sql, Object... parameters) {


        //连接数据库,关闭事务提交
        open();
        boolean flag = false;
        int insertId = 0;
  try {
            preparedStatement = connection.prepareStatement(sql);
            // 判断参数是否为空
            if (parameters != null) {
                //当参数不为空时循环取出每一条sql对应的参数预编译
                for (int j = 0; j < parameters.length; j++) {
                    preparedStatement.setObject(j + 1, parameters[j]);
                    
                }
               
            }
//                编译完成后提交sql语句
            preparedStatement.executeUpdate();
//            查询最后提交的sql的id
                String sqlSelect = "select LAST_INSERT_ID()";
                resultSet = preparedStatement.executeQuery(sqlSelect);
                resultSet.next();
                insertId = resultSet.getInt(1);
//            手动提交事物
        connection.commit();
    } catch(SQLException e) {
//            如果出现sql异常则回滚事物 并抛出异常信息
        try {
            connection.rollback();
        } catch (SQLException ex) {
             e.printStackTrace();
        }
         e.printStackTrace();
    }finally{
        close();
    }
        return insertId; //返回id
}




    /**
     * DML重载
     * @param sql  单条Sql操作
     * @param parameters sql操作参数
     * @return 完成状态
     */
    public boolean executeDML(String sql,Object... parameters){
        String[] sqlStr = {sql};
        boolean b = executeDML(sqlStr, parameters);
        return b;
    }


    /**
     * 多条SQL操作方法
     * @param sqls  传入多条SQL
     * @param parameters 传入多条SQL的参数数组
     * @return
     */
    public  boolean executeDML(String[] sqls,Object[]... parameters) {
        //连接数据库,关闭事务提交
        open();
        boolean flag = false;
        int updateCount = 0;
        try {
            //循环读取每一条sql
            for (int i = 0; i < sqls.length; i++) {
                logger.debug("第"+(i+1)+"条SQL>>>>>>>>"+sqls[i]);
                //将sql预加载
                preparedStatement = connection.prepareStatement(sqls[i]);

                
               // 判断参数是否为空
                if (parameters != null) {
                    //当参数不为空时循环取出每一条sql对应的参数预编译
                    for (int j = 0; j < parameters[i].length; j++) {
                        preparedStatement.setObject(j+1,parameters[i][j]);
                       
                    }
                    
                }
//                编译完成后提交sql语句
                updateCount = preparedStatement.executeUpdate();
            }
//            手动提交事物
            connection.commit();

            if (updateCount > 0) {
                flag = true;
            }

        } catch (SQLException e) {
//            如果出现sql异常则回滚事物 并抛出异常信息
            try {
                connection.rollback();
            } catch (SQLException ex) {
                e.printStackTrace();
            }
             e.printStackTrace();
        }finally {
            close();
        }
     return flag; //返回操作状态
    }

    /**
     * Dql数据库查询操作
     * @param clazz  Bean.class 反射
     * @param sql 查询sql语句
     * @param parameters 查询参数条件
     * @param <T> 类
     * @return 查询结果 List类型
     */
    public <T> List<T> executeDQL(Class<T> clazz,String sql, Object... parameters){
        //连接数据库,关闭事务提交
        open();
        List<T> arrayList = new ArrayList<T>();
        
        Field[] declaredFields = clazz.getDeclaredFields();
        
        T newInstance;
        try {
            
            preparedStatement = connection.prepareStatement(sql);
            
            if (parameters != null){
                for (int i = 0; i < parameters.length; i++) {
                   
                    preparedStatement.setObject(i + 1, parameters[i]);

                }
                
            }
            resultSet = preparedStatement.executeQuery();
            
            while (resultSet.next()){
                newInstance = clazz.newInstance();
                ResultSetMetaData metaData = resultSet.getMetaData();
                for (Field field:declaredFields){
                    for (int i = 1; i <= metaData.getColumnCount(); i++) {
                        String columnName = metaData.getColumnName(i);
                        if (columnName.equalsIgnoreCase(field.getName())){
                            field.setAccessible(true);
                            field.set(newInstance,resultSet.getObject(i));
                        }
                    }
                }
                arrayList.add(newInstance);

            }
        } catch (SQLException e) {
           e.printStackTrace();
        } catch (InstantiationException e) {
             e.printStackTrace();
        } catch (IllegalAccessException e) {
             e.printStackTrace();
        }finally {
            close();
        }
        return arrayList;
    }


    private void close(){
        if (connection != null) {
            try {
               
                connection.close();
              
            } catch (SQLException e) {
                 e.printStackTrace();
            }
        }
        if (preparedStatement!=null) {
            try {
                
                preparedStatement.close();
                
            } catch (SQLException e) {
                 e.printStackTrace();
            }
        }
    }


}