java JDBC操作Oracle数据库，使用反射自己写通用JDBC，封装单表操作，动态操作sql，没有表限制

网页左边，向下滑有目录索引，可以根据标题跳转到你想看的内容

效果演示

原表

运行效果
只需要传入一个实体类，即可完成对应功能，也就是随便找一个表，对应一个实体类，作为参数传入即可完成功能

一、环境搭建

创建一个maven项目并引入JDBC驱动依赖(不会maven就手动下载jar包，放在项目中然后导入环境，效果一样)

<dependency>
    <groupId>com.hynnet</groupId>
    <artifactId>oracle-driver-ojdbc</artifactId>
    <version>12.1.0.2</version>
</dependency>

建表

根据表建立实体类

package com.yzpnb.entity;

public class User {
     
    private Integer id;
    private String username;
    private Integer age;

    public Integer getId() {
     
        return id;
    }

    public void setId(Integer id) {
     
        this.id = id;
    }

    public String getUsername() {
     
        return username;
    }

    public void setUsername(String username) {
     
        this.username = username;
    }

    public Integer getAge() {
     
        return age;
    }

    public void setAge(Integer age) {
     
        this.age = age;
    }
}

二、源码与效果

源码

package com.yzpnb.mapper;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class JDBCMapper {
     
    Connection connection = null;//数据库连接对象
    Statement statement = null; //sql执行对象
    ResultSet resultSet = null;//结果集封装对象
    /**初始化数据库连接，获取对象*/
    public JDBCMapper() {
     
        //1、加载驱动
        try {
     
            Class.forName("oracle.jdbc.driver.OracleDriver");//反射驱动类
        } catch (ClassNotFoundException e) {
     
            e.printStackTrace();
        }
        //2、建立连接 url的格式为jdbc:oracle:连接方式:@ip地址:端口号:数据库名（ip地址localhost为本机ip） 第二个参数时用户名，第三参数是密码
        try {
     
            connection = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "yzp", "root");
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
        //3、获取sql执行对象，因为sql的执行需要知道操作的是哪个数据库，所以使用刚建立好的连接对象connection获取，此时sql执行对象的操作将针对connection的连接执行
        try {
     
            statement = connection.createStatement();
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
    }
    /**结果集迭代通用方法*/
    //根据结果集，返回list对象
    private List<Object> resultSetList(ResultSet resultSet) throws Exception {
     
        ArrayList<Object> list = new ArrayList<Object>();//创建list集合
        ResultSetMetaData md = resultSet.getMetaData(); //获得结果集结构信息,元数据
        int columnCount = md.getColumnCount();   //获得列数，用于我们循环遍历
        while (resultSet.next()) {
     //如果结果集没有下一条数据了，就结束循环
            Map<String,Object> rowData = new HashMap<String,Object>();//创建一个Map，保存对象
            for (int i = 1; i <= columnCount; i++) {
     
                rowData.put(md.getColumnName(i), resultSet.getObject(i));//将每一条数据都封装到map中
            }
            list.add(rowData);//将map添加到List集合中
        }
        return list;//返回list集合
    }
    /**数据库增删改查*/
    //1、通过传入的参数--实体类,反射获取其小写的类名，因为数据库表名都是小写，我们这里规定一个实体类代表一张表，并且实体类名为数据库表名的驼峰命名
    public List<Object> selectAll(Object obj){
     
        //因为Oracle严格区分大小写，user会直接转换为USER，而方法就是"user"，通过双引号来阻止Oracle区分
        String sql = "select * from \""+obj.getClass().getSimpleName().toLowerCase()+"\"";
        List<Object> list = null;
            try {
     
            resultSet = statement.executeQuery(sql);//使用sql执行对象的executeQuery执行数据库查询操作，然后返回结果集给结果集对象
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
        //封装结果集返回
        try {
     
            list = this.resultSetList(resultSet);
        } catch (Exception e) {
     
            e.printStackTrace();
        }
        System.out.println(sql);
        return list;
    }
    //2、添加一条数据到数据库
    public Integer insert(Object obj) {
     
        Field[] fields = obj.getClass().getDeclaredFields();//获取对象所有属性

        String sql = "insert into \""+obj.getClass().getSimpleName().toLowerCase()+"\"(";//拼接sql
        for (Field field:fields) {
     
            sql += "\""+field.getName()+"\",";
        }
        sql += ") values(";
        for (Field field:fields) {
     
            try {
     
                //此对象可以获取类对象的信息，下面是提供的构造方法之一，表示获取指定属性名的属性名，类型和get、set方法的信息
                //这是获取的一个结果java.beans.PropertyDescriptor[name=id; propertyType=class java.lang.Integer; readMethod=public java.lang.Integer com.yzpnb.entity.User.getId(); writeMethod=public void com.yzpnb.entity.User.setId(java.lang.Integer)]
                PropertyDescriptor pd = new PropertyDescriptor(field.getName(), obj.getClass());
                Method readMethod = pd.getReadMethod();//获取get方法
                Object invoke = readMethod.invoke(obj);//通过反射执行get方法，方法返回结果保存为Object对象
                if(invoke != null){
     
                    //如果属性类型是String，那么拼接时加引号
                    if(pd.getPropertyType().getName().equals("java.lang.String")){
     
                        sql+="\'"+invoke+"\'"+",";
                    }else{
     
                        sql +=invoke+",";//拼接sql
                    }
                }
            } catch (Exception e) {
     
                e.printStackTrace();
            }
        }
        sql+=")";
        sql = sql.replace(",)", ")");//去掉字符串多余逗号
        System.out.println(sql);
        try {
     
            ResultSet resultSet = statement.executeQuery(sql);
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
        return 1;
    }
    //3、修改一条数据到数据库
    public Integer updateById(Object obj){
     
        Object id = null;
        Field[] fields = obj.getClass().getDeclaredFields();//获取对象所有属性
        String sql = "update "+"\""+obj.getClass().getSimpleName().toLowerCase()+"\" set ";
        for(Field field:fields){
     
            try {
     
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(field.getName(), obj.getClass());
                if(field.getName().equals("id")){
     
                    id = propertyDescriptor.getReadMethod().invoke(obj);
                    continue;
                }
                Method readMethod = propertyDescriptor.getReadMethod();
                Object invoke = readMethod.invoke(obj);
                if(invoke != null){
     
                    sql+="\""+field.getName()+"\"=";
                    if(propertyDescriptor.getPropertyType().getName().equals("java.lang.String")){
     
                        sql+="\'"+invoke+"\',";
                    }else{
     
                        sql+=invoke+",";
                    }
                }
            } catch (Exception e) {
     
                e.printStackTrace();
            }
        }
        sql+="where \"id\" = "+id;
        sql = sql.replace(",where"," where");
        System.out.println(sql);
        try {
     
            statement.executeUpdate(sql);
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
        return 1;
    }
    //删除数据
    public Integer deleteById(Object obj){
     
        String sql = "delete from \""+obj.getClass().getSimpleName().toLowerCase()+"\" where \"id\" = ";
        try {
     
            PropertyDescriptor propertyDescriptor = new PropertyDescriptor("id", obj.getClass());
            sql+=propertyDescriptor.getReadMethod().invoke(obj);
        } catch (Exception e) {
     
            e.printStackTrace();
        }
        System.out.println(sql);
        try {
     
            statement.executeQuery(sql);
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
        return 1;
    }
    /** 关闭连接*/
    public void closeJDBC(){
     
        try {
     
            connection.close();
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
        try {
     
            statement.close();
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
        try {
     
            resultSet.close();
        } catch (SQLException e) {
     
            e.printStackTrace();
        }
    }
}

package com.yzpnb.controler;

import com.yzpnb.entity.User;
import com.yzpnb.mapper.JDBCMapper;

import java.util.List;

public class TestJDBC {
     


    public static void main(String[] args) {
     
        JDBCMapper jdbcMapper = new JDBCMapper();
        /*查询数据*/
        List<Object> objects = jdbcMapper.selectAll(new User());

        System.out.println("查询结果为："+objects.toString());

        /*插入数据*/
        User user = new User();
        user.setId(10);
        user.setUsername("Test");
        user.setAge(15);
        jdbcMapper.insert(user);
        /*修改数据*/
        User user1 = new User();
        user.setId(2);
        user.setUsername("张三");
        jdbcMapper.updateById(user1);
        /*删除数据*/
        User user2 = new User();
        user2.setId(1);
        jdbcMapper.deleteById(user2);
        /*关闭连接*/
        jdbcMapper.closeJDBC();
    }
}