JDBC+MYSQL封装操作的增删改查

通过JDBC的操作连接，Java数据库连接，是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口(位于jdk的java.sql中)。我们通常说的JDBC是面向关系型数据库的，提供了诸如查询、更新、删除、增加数据库中数据的方法。在使用时候需要导入具体的jar包，不同数据库需要导入的jar包不同。

第一步 数据库的创建与表的创建

这里我所使用的是Java2304该数据库，创建了表work，表字段和数据如下图：

 

 

第二步 创建项目

 

 在src目录下，创建db.properties文件，配置信息如下：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/java2304?useSSL=false
user=root
password=root

创建文件lib，下面导入项目需要的三个文件包，当然创建项目时用到maven时，可以通过maven自动导入项目所需要的包，会更加方便快捷，这里我所用的是手动导入所需要的依赖。

第三步 创建实体类，并与数据库建立连接

这里我在src\com\zwj\entity目录下创建了与数据库表相关的对象：

package com.zwj.entity;

public class Work {
    private Integer id;
    private String name;
    private Integer age;
    private  String info;

    public Work() {

    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Work{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", info='" + info + '\'' +
                '}';
    }
}

在utils包中创建JdbcUntil的工具类，封装对数据库的连接操作以及关闭操作，随用随拿：

package com.zwj.utils;

import java.io.FileInputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 1.获取Connection对象
 * 2.关闭资源
 */
public class JdbcUtil {
    private static String url = null;
    private static String user =null;
    private static String password = null;
    static {
        try {
        //只要JdbcUtil类加载了，就会执行静态代码块中的代码
        //读取配置文件中的信息：properties文件
        //Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。
        // 属性列表中的每个键及其对应的值都是一个字符串。
            Properties properties = new Properties();
            properties.load(new FileInputStream("src/db.properties"));
            //数据都在properties 对象中
            String diver = properties.getProperty("driver");
            url = properties.getProperty("url");
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            Class.forName(diver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection () {

        Connection connection = null;
        try {
            connection = DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return  connection;
    }

    //关闭资源
    //增删改  需要关闭两个   查 关闭三个
    public static void close (Connection connection) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void close (Statement statement, Connection connection) {
        try {
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
    public static void close (ResultSet resultSet, Statement statement, Connection connection) {
        try {
            resultSet.close();
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

接下来就可以在代码中具体实现数据库的增删改查操作了，我们这里先在a_mysql包下创建一个WorkDao文件，在MVC模式里，这里的代码用于封装数据库的增删改查所实现的具体方法，这样就不用将SQL的增删改查代码卸载main主函数中了，我这里是写在DAO层里来具体实现。

package com.zwj.a_mysql;

import com.zwj.entity.Work;
import com.zwj.utils.BaseDao;

import java.util.List;

public class WorkDao extends BaseDao {
    public void insert() {
        String sql = "insert into work (name, age, info) values(?, ?, ?)";
        Object[] objs = {"老万", 19, "嘻嘻老师的汉"};
        super.update(sql, objs);
    }
    public void delete () {
        String sql = "delete from work where id  = ?";
        Object[] obj = {3};
        super.update(sql, obj);
    }
    public void select () {
        String sql = "select * from work";
        List<Work> query = super.query(sql, null, Work.class);
        System.out.println(query);
    }


}

在BaseDao这个类里就是具体的实现了：

package com.zwj.utils;

import org.apache.commons.beanutils.BeanUtils;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 只有两个方法：
 *  1.增删改
 *  2.查
 */
public class BaseDao {

    /**
     * 增删改
     * @param sql   需要传入sql语句
     * @param parameters   对sql的?进行赋值
     * @return  受影响的行数
     */
    // String sql = "insert into work (name, age, info) values(?, ?,?)";
    // Object[] objs = {"煮鸡蛋", 34, "cxdshjn"};
    //baseDao.update(sql, objs);
    public int update (String sql, Object[] parameters) {
        //1.获取数据路的连接的对象  从另外一个工具类中去获取的
        Connection connection = JdbcUtil.getConnection();
        //2.获取预处理的搬运工对象去预处理sql语句
        PreparedStatement preparedStatement = null;
        try {
            preparedStatement = connection.prepareStatement(sql);
            //3.现在对sql语句参数进行赋值， 你知道有几个参数吗因为参数不确定
            //获取参数的个数  靠参数元数据
            int parameterCount = preparedStatement.getParameterMetaData().getParameterCount();
            //System.out.println(parameterCount);
            //4.循环进行赋值
            // String sql = "insert into work (name, age, info) values(?, ?,?)";
            // Object[] objs = {"供电", 12, "23u"};  3
            if (parameters != null && parameters.length == parameterCount) {
                //才让你赋值
                for (int i = 1; i <= parameterCount; i++) {
                    //i = 1`   setObject(1, "供电")
                    //i=2  setObject(2, 12)
                    //i=3  setObject(3, "23u")
                    preparedStatement.setObject(i, parameters[i - 1]);
                }
            }
            //5.执行sql语句
            int i = preparedStatement.executeUpdate();
            return i;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(preparedStatement, connection);
        }
        return 0;
    }
    //查询的方法 咱们需要关注什么？查询的数据是要赋值给一个实体类对象

    /**
     *
     * @param sql
     * @param parameters
     * @param cls  查询出来的数据赋值给一个对象
     * @param <T>
     * @return
     */



//    public void select () {
//        String sql = "select * from work";
//        List<Work> query = super.query(sql, null, Work.class);
//        System.out.println(query);
//    }

    //super.query("select name,age from emp where id = ?", null, Emp.class)
    public <T> List<T> query (String sql, Object[] parameters, Class<T> cls) {
        //1.连接数据库的对象 获取
        Connection connection = JdbcUtil.getConnection();


        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            //2.获取预处理的搬运工对象
            preparedStatement = connection.prepareStatement(sql);
            //3.获取参数的个数
            int parameterCount = preparedStatement.getParameterMetaData().getParameterCount();
            //4.对?进行赋值
            if(parameters != null && parameters.length == parameterCount) {
                for (int i = 1; i <= parameterCount; i++) {
                    preparedStatement.setObject(i, parameters[i - 1]);
                }
            }
            //5.执行sql语句
            resultSet = preparedStatement.executeQuery();
            //6.创建一个空的集合
            List<T> list = new ArrayList<>();
            //7.获取结果集元数据，通过元数据获取字段的个数和字段的名字
            ResultSetMetaData metaData = resultSet.getMetaData();
            //8.通过元数据的对象获取字段的个数
            /**
             * id  name  age  info      《=
             * 1  狗蛋    12   大数据   《=
             * 2  嘻嘻  18  撒娇年休假
             * 3  大黄  89  水性凝胶剂
             */
            int columnCount = metaData.getColumnCount();

            /**
             * resultSet.next()
             *      第一条数据 ：
             *          内层for循环
             *              i=1 1<4  id  getObject("id")   1 i++
             *               i=2 2<4  name  getObject("name") 狗蛋 i++
             *               i=3 3<4  age...
             *    resultSet.next()
             *          第二条数据:
             *              内层for循环
             *              *              i=1 1<4  id  getObject("id")   2 i++
             *              *               i=2 2<4  name  getObject("name") 嘻嘻 i++
             *              *               i=3 3<4  age..
             */
            //9.遍历数据
            while (resultSet.next()) {
                //往下遍历每一行的数据的
                //10.通过Class对象获取所对应的类对象
                //Work.class->Work work = new Work()
                //Person.calss->person person = new Person();
                T t = cls.getConstructor(null).newInstance(null);

                for (int i = 1; i <= columnCount; i++) {//获取字段的
                    //11.获取列(字段)的名字
                    String columnName = metaData.getColumnName(i);
                    //System.out.println(columnName);
                    //12.通过字段获取值
                    Object value = resultSet.getObject(columnName);
                    System.out.println(value);
                    //13.获取数据库重点数据之后，将数据赋值一个对象，得有类啊
                    //BeanUtils.setProperty(对象， 属性， 值)
                    BeanUtils.setProperty(t, columnName, value);
                }
                //14.每次while循环一次 存到集合中
                list.add(t);
            }
            return list.size() != 0 ? list : null;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //15.关闭资源
            JdbcUtil.close(resultSet, preparedStatement, connection);
        }
        return null;

    }

}

最后在Demo1的主函数里实现：

package com.zwj.a_mysql;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        WorkDao workDao = new WorkDao();
        //workDao.insert();
        //workDao.delete();
        workDao.select();
    }
}