JDBC的封装


前言

Java数据库连接,(Java Database Connectivity,简称JDBC)是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法。


一、JDBC基本实现

//加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc.mysql://127.0.0.1:3306/test","root","123456");
//获取执行sql语句对象
Statement stmt=conn.createStatement();
//执行sql语句
ResultSet rs=stmt.executeQuery(Sql);//执行查询(select)语句
ResultSet rs=stmt.executeUpdate(Sql);//执行update、insert、delete
//处理结果集
if(rs.next){
	...
}
//关闭连接
rs.close();
ps.close();
conn.close();

二、JDBC的封装

由于每次对数据库进行操作时都需要进行以上一系列操作,这样就会出现很多重复代码,所以就出现了jdbc的封装。

package com.softeem.jdbc03.utis;

import com.alibaba.druid.pool.DruidDataSource;

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

/**
 * @Author Ea'son 2020/12/11 12:03
 */
public class DButils3 {

    /**
     * 驱动类路径
     */
    private static final String DRIVER_CLASS = "com.mysql.jdbc.Driver";
    /**
     * URl地址
     */
    private static final String URL = "jdbc:mysql://localhost:3306/test1";
    /**
     * 登录数据库服务器的账号
     */
    private static final String USER = "root";
    /**
     * 登录数据库服务器的密码
     */
    private static final String PASSWORD = "123456";

    /**
     * 初始连接数
     */
    private static final int INIT_SIZE = 1;
    /**
     * 最大活动连接数
     */
    private static final int MAX_ACTIVE = 5;
    /**
     * 最长等待连接获取时间
     */
    private static final long MAX_WAIT = 5000;
    /**
     * 最小闲置连接数
     */
    private static final int MIN_IDLE = 1;

    /**
     * 声明数据源
     */
    private static DruidDataSource dataSource;

    static {
        dataSource = createDataSource();
    }

    /**
     * 创建连接池并返回
     *
     * @return
     */
    private static DruidDataSource createDataSource() {
        //创建连接池对象
        dataSource = new DruidDataSource();
        //设置连接数据库的基本字符串
        dataSource.setUrl(URL);
        dataSource.setUsername(USER);
        dataSource.setPassword(PASSWORD);

        //设置连接池的初始参数
        dataSource.setInitialSize(INIT_SIZE);
        dataSource.setMaxActive(MAX_ACTIVE);
        dataSource.setMaxWait(MAX_WAIT);
        dataSource.setMinIdle(MIN_IDLE);

        return dataSource;
    }

    /**
     * 返回数据库连接对象
     *
     * @return
     */
    public static Connection getConn() {
        try {
            //当连接池对象为null或者连接池对象被关闭时,重新创建连接池
            if (dataSource == null || dataSource.isClosed()) {
                dataSource = createDataSource();
            }
            return dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭资源
     *
     * @param rs   结果集
     * @param stat 处理sql语句的对象
     * @param conn 数据库连接对象
     */
    public static void close(ResultSet rs, Statement stat, Connection conn) {
        //ctrl+alt+t
        try {
            if (rs != null) {
                rs.close();
            }
            if (stat != null) {
                stat.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 封装通用的更新操作(即通过该方法实现对于任意数据表的insert,update,delete操作)
     *
     * @param sql    需要被执行的sql语句
     * @param params 执行sql语句时需要传递进去参数
     * @return 执行结果
     */
    public static boolean exeUpdate(String sql, Object... params) {
        Connection conn = getConn();
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
            //当传入参数不为null时执行预处理
            if (Objects.nonNull(params)) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            //执行更新
            return ps.executeUpdate() > 0;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DButils3.close(null, ps, conn);
        }
        return false;
    }

    /**
     * 实现通用更新操作的方法,连接是需要外部提供,
     * 此处的异常需要抛出,如果捕获,该方法如果出现异常,会直接被捕获
     * 后续调用此方法时,如果该方法出现异常,会被认为没有发现异常,后续依旧会执行commit提交事务
     *
     * @param conn
     * @param sql
     * @param params
     * @return
     */
    public static boolean exeUpdate(Connection conn, String sql, Object... params) throws SQLException {
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
            //当传入参数不为null时执行预处理
            if (Objects.nonNull(params)) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            //执行更新
            return ps.executeUpdate() > 0;
        } finally {
            DButils3.close(null, ps, null);
        }
    }

    /**
     * 将查询的结果存储到一个List集合中,集合中的 每一个元素即一个Map对象
     *
     * @return
     */
    public static List<Map<String, Object>> queryToMap(String sql, Object... params) {
        //先声明一个List集合存储所有查询的数据(内部的每一条数据使用一个map对象表示)
        List<Map<String, Object>> list = new ArrayList<>();
        Connection conn = DButils2.getConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(sql);
            //执行预处理(如果存在占位符,则为占位符填充具体的值)
            if (Objects.nonNull(params)) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            //执行查询
            rs = ps.executeQuery();
            //获取结果集元数据对象
            ResultSetMetaData rsmd = rs.getMetaData();
            //获取总查询列数
            int columnCount = rsmd.getColumnCount();
            //遍历结果集
            while (rs.next()) {
                //每一次循环执行创建一个Map(查询到一条数据)
                Map<String, Object> map = new HashMap<>();
                //获取每一列的列标签
                for (int i = 1; i <= columnCount; i++) {
                    //获取指定的列名称
                    String cname = rsmd.getColumnName(i);
                    //根据列标签获取列值
                    Object value = rs.getObject(i);
                    //将一个查询列装入map集合
                    map.put(cname, value);
                }
                //将Map集合(javabean)存入到list
                list.add(map);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(rs, ps, conn);
        }
        return list;
    }
    /**
     * 封装通用查询单条数据的方法
     *
     * JDBC,反射,集合框架,lambda表达式,新增Objects类
     *
     * @param <T>
     * @param t
     * @param sql
     * @param params
     * @return
     */
    public static <T> T queryOne(Class<T> t, String sql, Object... params) {
        // 获取查询到到数据集合
        List<Map<String, Object>> list = queryToMap(sql, params);
        if (list.size() > 0) {
            // 获取一个Map对象
            Map<String, Object> map = list.get(0);
            // 将map集合转换为Javabean并返回
            return mapToBean(map, t);
        }
        return null;
    }

    /**
     * 封装通用查询多条数据的方法
     *
     * @param <T>
     * @param t
     * @param sql
     * @param params
     * @return
     */
    public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
        List<T> list = new ArrayList<T>();
        // 获取所有查询的到的数据
        List<Map<String, Object>> maps = queryToMap(sql, params);
        // 遍历集合中每一条数据(map)
        maps.forEach(m -> {
            // 将map转换为Javabean
            T obj = mapToBean(m, t);
            // 将Javabean装入list
            list.add(obj);
        });
        return list;
    }

    /**
     * 将Map集合转换为一个确定的类型
     *
     * @param <T>
     * @param map
     * @param t
     * @return
     */
    private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
        try {
            // 根据提供的Class对象创建对应类型的Object
            T obj = t.newInstance();
            map.forEach((k, v) -> {
                try {
                    // 根据Field名称获取字段对象
                    Field field = t.getDeclaredField(k);
                    // 设置字段的可访问性
                    field.setAccessible(true);
                    // 为字段设置值
                    field.set(obj, v);
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                } catch (SecurityException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
            return obj;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        // 返回对象
        return null;
    }
}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用Java JDBC封装数据库事务的代码示例: ```java import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement; public class TransactionExample { private static final String DB_URL = "jdbc:mysql://localhost:3306/mydatabase"; private static final String DB_USER = "root"; private static final String DB_PASSWORD = "password"; public static void main(String[] args) { Connection connection = null; Statement statement = null; try { // Establish database connection connection = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD); // Turn off auto-commit mode connection.setAutoCommit(false); // Execute SQL statements within a transaction statement = connection.createStatement(); statement.executeUpdate("INSERT INTO users (username, password) VALUES ('user1', 'pass1')"); statement.executeUpdate("INSERT INTO users (username, password) VALUES ('user2', 'pass2')"); // Commit transaction connection.commit(); System.out.println("Transaction completed successfully."); } catch (SQLException e) { // Rollback transaction in case of errors try { if (connection != null) { connection.rollback(); System.out.println("Transaction rolled back."); } } catch (SQLException ex) { ex.printStackTrace(); } e.printStackTrace(); } finally { // Close resources try { if (statement != null) { statement.close(); } if (connection != null) { connection.close(); } } catch (SQLException e) { e.printStackTrace(); } } } } ``` 在上面的代码中,我们首先建立了一个数据库连接,然后通过调用 `setAutoCommit(false)` 方法来关闭自动提交模式,这样将使所有的 SQL 语句在一个事务中执行。接下来,我们执行了两个 SQL 语句来插入两条用户记录。如果这些语句都执行成功,我们将调用 `commit()` 方法来提交事务。如果在执行 SQL 语句时出现错误,我们将调用 `rollback()` 方法来回滚事务。最后,我们关闭了所有的数据库连接和语句对象。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值