自行封装JDBCUtils

自己封装JDBCUtils

package com.javasm.util;

import com.javasm.bean.Emp;
import com.javasm.constants.JDBCConstants;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author：Zxb
 * @Version：1.0
 * @Date：2022/12/12-11:38
 * @Since：jdk1.8
 * @Description：
 */
public class JDBCUtils {
    /**
     * 获取数据库连接对象
     *
     * @return
     */
    public static Connection getConnection() {
        try {
            //加载驱动（JDK1.8之后自动加载）
            Class.forName(JDBCConstants.DRIVER);
            //获取连接对象
            return DriverManager.getConnection(JDBCConstants.URL,
                    JDBCConstants.USER, JDBCConstants.PASSWORD);
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 判断连接是否成功
     * @param connection
     * @return
     */
    public static boolean isConnection(Connection connection) {
        try {
            if (connection != null && !connection.isClosed()) {
               // System.out.println("数据库连接成功！");
                return true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 增删改的资源回收
     * 回收顺序：先回收执行对象再断开连接
     * @param connection
     * @param statement
     */
    public static void close(Connection connection,Statement statement){
        //执行对象不为null，且执行对象连接就断开
        try {
            if(statement!=null&&!statement.isClosed()){
                statement.close();
            }
            //是否连接，连接就断开
            if(isConnection(connection)){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    /**
     * 查询的资源回收
     * 查询要显示结果集，
     * 回收顺序：先回收结果集，再回收执行对象，最后断开连接
     * @param connection
     * @param statement
     * @param resultSet
     */
    public static void close(Connection connection, Statement statement, ResultSet resultSet){
        try {
            //结果集不为null，且结果集连接就断开
            if(resultSet!=null&&!resultSet.isClosed()){
                resultSet.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        close(connection, statement);
    }

    /**
     * 执行增删改操作
     * @param sql
     * @param params
     * @return
     */
    public static int update(String sql,Object...params){
        int n=0;
        //获取连接对象
        Connection connection =getConnection();
        //执行对象
        PreparedStatement statement = null;
        //先判断
        if(isConnection(connection)){
            try {
                //获取执行对象
                statement=connection.prepareStatement(sql);
                //解决参数
                if(params!=null&&params.length>0){
                    for (int i = 0; i < params.length; i++) {
                        statement.setObject((i+1),params[i]);
                    }
                }
                //执行
                n=statement.executeUpdate();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                close(connection,statement);
            }
        }
        return n;
    }

    /**
     * 查询
     * @param sql
     * @param clazz
     * @param params
     * @param <T>
     * @return
     */
    public  static <T>List<T> query(String sql,Class clazz,Object...params){
        List<T> list = new ArrayList<>(10);
        //获取数据库连接对象
        Connection connection = getConnection();
        //执行
        PreparedStatement statement = null;
        //结果集
        ResultSet resultSet = null;
        //先判断
        if(isConnection(connection)){
            try {
                //获取执行对象
                statement = connection.prepareStatement(sql);
                //解决参数
                if(params!=null&&params.length>0){
                    for (int i = 0; i < params.length; i++) {
                        statement.setObject((i+1),params[i]);
                    }
                }
                //执行查询
                resultSet = statement.executeQuery();
                //获取元数据
                ResultSetMetaData metaData=resultSet.getMetaData();
                //获取列的个数
                int columnCount = metaData.getColumnCount();
                //判断是否有下一行数据
                while (resultSet.next()){//每一行
                    Object object = clazz.newInstance();
                    for (int i = 1; i <= columnCount; i++) {//每一列
                        //获取列名
                        String label = metaData.getColumnLabel(i);
                        //获取列对应的数据类型
                        String className=metaData.getColumnClassName(i);
                        //根据列名获取对应的值
                        Object value = resultSet.getObject(label);
                        //赋值
                        invoke(clazz,label,className,object,value);
                    }
                    //将对象存入到集合中
                    list.add((T) object);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } finally {
                close(connection, statement, resultSet);
            }
        }
        return list;
    }

    /**
     * 赋值
     * @param clazz
     * @param label
     * @param className
     * @param object
     * @param value
     */
    private static void invoke(Class clazz,String label,String className,Object object,Object value){
        //获取方法名
        String methodName = ClassUtils.getMethodName(label);
        //获取方法的参数类型
        Class aClass=ClassUtils.getClass(className);
        try {
            //通过反射获取反射方法对象
            Method method = clazz.getMethod(methodName, aClass);
            //赋值
            method.invoke(object,value);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

ClassUtils

package com.javasm.util;

/**
 * @Author：Zxb
 * @Version：1.0
 * @Date：2022/12/13-11:36
 * @Since：jdk1.8
 * @Description：
 */
public class ClassUtils {

    /**
     * 获取方法名
     * @param labelName
     * @return
     */
    public static String  getMethodName(String labelName){
        //emp_id --> setEmpId
       StringBuilder stringBuilder = new StringBuilder("set");
       //根据_分割字符串 emp_id
       String[] split = labelName.split("_");//emp id
        for (String s : split) {//遍历每个单词
            stringBuilder.append(Character.toUpperCase(s.charAt(0)));//分割后的第一个字母大写E /第二轮拼接 EmpI
            stringBuilder.append(s.substring(1));        //截取索引1之后的数据mp，拼接Emp       / EmpId
        }
        return stringBuilder.toString();
    }

    /**
     * 获取对应的类型
     * @param className
     * @return
     */
    public static Class getClass(String className){
        if(className.equals("java.sql.Date")||className.equals("java.sql.Timestamp")){
            className="java.util.Date";
        }
        Class<?> aClass = null;
        try {
            aClass = Class.forName(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return aClass;
    }
}

JDBCConstants

package com.javasm.constants;

/**
 * @Author：Zxb
 * @Version：1.0
 * @Date：2022/12/12-11:02
 * @Since：jdk1.8
 * @Description：
 */
public class JDBCConstants {
    //账号和密码
    public static final String USER = "root",PASSWORD="123456";

    public static final String URL ="jdbc:mysql://localhost:3306/test_db?useSSL=false";//useSSL=false忽略版本
    //数据库驱动地址
    public static final String DRIVER="com.mysql.jdbc.Driver";
}