前言：本篇文章写于学习JAVA-JDBC相关知识的路上，记录当前学习点滴，希望对你有帮助。

文章目录

• 一、BaseDao是什么？
• 二、使用步骤
• • 1.引入库
  • 2.读写数据
• 总结

一、BaseDao是什么？

BaseDAO一般是提供从数据库 增加、删除、修改记录、查询所有记录、查询符合某个条件记录、取得某条记录等方法的底层数据操作自定义类。是一种接口代码，公共方法的接口类。

二、使用步骤

1.引入库

package com.xxx.util;

import com.xxx.entity.DirectorEntity;
import com.xxx.entity.UserinfoEntity;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;

2.读写数据

public class BaseDao<T> {
    //声明配置文件读取器
    protected ResourceBundle rb;
    //声明数据库驱动
    protected String driver;
    //声明链接地址
    protected String url;
    //声明用户名
    protected String username;
    //声明密码
    protected String password;
    /****************************************/
    //声明数据库链接类
    protected Connection conn;
    //声明数据库执行类
    protected PreparedStatement statement;
    //声明数据库结果类
    protected ResultSet rs;

    /****************************************/

    /**
     * 初始化basedao 并获取配置文件进行赋值
     */
    public BaseDao() {
        //加载配置文件
        rb = ResourceBundle.getBundle("db");
        //获取配置文件中的值
        driver = rb.getString("jdbc.driver");
        url = rb.getString("jdbc.url");
        username = rb.getString("jdbc.username");
        password = rb.getString("jdbc.password");
    }

    //打开链接并获取链接
    private void openConn() {
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, username, password);

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

    /**
     * @param sql  执行的sql语句
     * @param objs 占位符数组
     * @return 受影响的行数
     */

    public int baseUpdate(String sql, Object... objs) {
        try {
            //格式化执行器内存
            formatterStatement(sql, objs);
            //返回执行结果
            return statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeAll();
        }
        //try中如果没有返回，则表示执行失败，必定返回0
        return 0;
    }

    /**
     * @param tClass 泛型的类对象
     * @param sql    执行的Sql
     * @param objs   占位符数组
     * @return 处理后的List集合
     */

    //泛型的抽象，抽象的抽象，类类
    protected List<T> baseQuery(Class<T> tClass, String sql, Object... objs) {
        //初始化数据集合
        List<T> dataList = new ArrayList<>();
        try {
            //格式化执行器内容
            formatterStatement(sql, objs);
            //执行查询获取结果集
            rs = statement.executeQuery();
            //获取数据库表的元数据信息
            ResultSetMetaData resultSetMetaData = rs.getMetaData();
            //遍历结果
            while (rs.next()) {
                //实例化泛型对象
                T t = tClass.newInstance();
                //获取所有对象属性
                Field[] fs = tClass.getDeclaredFields();
                //获取对象的父级实体类
                Class pClass=tClass.getSuperclass();
                //获取父级对象的所有属性
                Field[] pfs=pClass.getDeclaredFields();
                //初始化属性集合
                List<Field>fieldList=new ArrayList<>();
                for(Field f:fs){
                    fieldList.add(f);
                }
                for(Field f:pfs){
                    fieldList.add(f);
                }

                //获取总列数
                int columnCount = resultSetMetaData.getColumnCount();
                //遍历所有列
                for (int i = 0; i < columnCount; i++) {
                    //获取列名
                    String columnName = resultSetMetaData.getColumnName(i + 1);
                    //初始化新的列名
                    StringBuilder newColumnName=new StringBuilder(columnName);
                    //判断列名中是否存在下划线(_)
                    if(columnName.indexOf("_")>0){
                        //根据下划线拆分字符创并得到数组
                        String[] cns=columnName.split("_");
                        //给新的列名重新赋值
                        newColumnName=new StringBuilder(cns[0]);

                        //从第二个内容开始遍历数组
                        for(int j=1;j<cns.length;j++){
                            //获取数组中的每个单词
                            String word=cns[j];
                            //获取首字符并大写
                            String w=word.substring(0,1).toUpperCase();
                            //获取首字符以外的内容
                            String d=word.substring(1);
                            //拼接成新的字符串
                            String newWord=w+d;
                            //拼接完整字符串
                            newColumnName.append(newWord);
                        }
                    }


                    //遍历实体类的所有属性
                    for (Field f : fieldList) {
                        //获取属性名
                        String fieldName = f.getName();
                        //比较属性名和列名是否相同
                        if (fieldName.equals(newColumnName.toString())) {
                            //开启赋值功能
                            f.setAccessible(true);
                            //设置指定属性的值
                            f.set(t, rs.getObject(columnName));
                        }
                    }
                }
                dataList.add(t);
            }

        } catch (SQLException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        //返回处理后的List集合
        return dataList;
    }

    /**
     *
     * @param tClass  泛型的类对象
     * @param sql     执行的SqL
     * @param objs     占位符数组
     * @return          结果实体类
     */
    public T baseQueryEntity(Class<T>tClass,String sql,Object ...objs){
        //查询结果获取集合
        List<T> list=baseQuery(tClass,sql,objs);
        //判断结果集是否合法
        if(list.size()>1){
            //主动抛出异常来终止代码的执行
            throw new RuntimeException("查询结果为"+list.size()+"条，不符合规定!");
        }
        if(list.size()==0){
            return null;
        }
        //有结果则返回数据
        return list.get(0);
    }


    //公用方法
    private void formatterStatement(String sql, Object... objs) {
        try {
            //打开链接
            openConn();
            //获取执行器
            statement = conn.prepareStatement(sql);
            //遍历占位符数组进行占位符赋值
            for (int i = 0; i < objs.length; i++) {
                //占位符赋值
                statement.setObject(i + 1, objs[i]);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }


    //关闭所有的流
    private void closeAll() {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) {
        BaseDao<UserinfoEntity> baseDao = new BaseDao<>();
        String sql = "select * from mm_userinfo";
        List<UserinfoEntity> userList = baseDao.baseQuery(UserinfoEntity.class, sql);
        for(int i=0;i<userList.size();i++)
        {
            System.out.println(userList.get(i));
        }

        BaseDao<DirectorEntity> directorDao = new BaseDao<>();
        String sql2 = "select * from mm_director";
        List<DirectorEntity> directorList = directorDao.baseQuery(DirectorEntity.class, sql2);
        for(DirectorEntity director:directorList){
            System.out.println(director);
        }
    }
}

总结