JDBC的学习及工具类JDBCUtiles-CSDN博客

本文链接：https://blog.csdn.net/vanliujian/article/details/106039900

JDBC

JDBC是用来干什么的：是用来操作数据库，执行SQL语句

1、基本概念：Java Database Connectivity， Java语言操作数据库
2、本质：官方定义的一套操作所有关系型数据库的规则及接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口(JDBC)来编程，真正执行的代码是驱动jar包中的实现类

public static void main(String[] args) {
        //1.导入驱动jar包
        //2.注册驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Statement stmt = null;    //定义这个的时候放在try的外面，好让释放资源的时候能够到。
        Connection conn = null;
        try {
            //3.获取数据库连接对象
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=gbk&useSSL=false", "root", "密码");
            //4.定义sql语句
            String sql = "update account set balance = 500 where id = 1";
            // 5.获取执行sql的对象statement
            stmt = conn.createStatement();
            // 6.执行sql
            int count = stmt.executeUpdate(sql);
            // 7.处理结果
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 8. 释放资源      释放资源都是在finally中释放。
            if(stmt != null) {
                try {
                    stmt.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(conn != null) {
                try {
                    conn.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
}

//注意DML影响行数返回的结果，DDL没有返回结果只会返回个0

详解各个对象：

1. DriverManager：驱动管理对象
功能：① 注册驱动：告诉程序该使用哪一个数据库执行jar
写代码使用：Class.forName(“com.mysql.jdbc.Driver”);
//mysql5版本之后的驱动jar包，可以省略注册驱动
② 获取数据库连接：方法：static Connection getConnection(String url,String user,String password) 参数：url：指定连接的路径

语法：jdbc:mysql://ip地址(域名):端口号/数据库名称

例子：jdbc:mysql://localhost:3306/test

细节：如果连接的是本机的MySQL服务器，并且MySQL服务器端口为3306，

则url可简写为：jdbc:mysql///数据库名称

user：用户名

password：密码

2. Connection：数据库连接对象

1、功能：

① 获取执行sql的对象

* Statement createStatement()

* PreparedStatement prepareStatement(String sql)

② 管理事务

* 开启事务：void setAutoCommit(boolean autoCommit)：调用该方法设置参数为false，即开启事务

* 提交事务：void commit()

* 回滚事务：rollback()

3. Statement：执行sql的对象

1、执行sql

① boolean execute(String sql)：可以执行任意的sql语句 (了解)

② int excuteUpdate(String sql)：执行DML(insert、update、delete)语句、DDL(create、alter、drop)语句

* 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功返回值 > 0 时就执行成功，反之则失败。

③ ResultSet executeQuery(String sql)：执行DQL(select) 语句

4. ResultSet：结果集对象

next()：游标向下移动一行 (判断当前行是否为最后一行末尾，如果是就返回false，不是就返回true)

getXxx(参数)：获取数据

Xxx：代表所要获取的那一列数据的数据类型

参数：① Int类型的数：代表列的编号例：getInt(1); // 获取那一行中第一列的数据

② String类型的字符串：代表列名称例：getString("balance"); // 获取那一行中balance所在的那一列的数据

注意：

使用步骤：

1、游标向下移动一行

2、判断是否有数据：next()的返回值是boolean型，也有个返回值，判断当前行是否为最后一行末尾，就是判断是否有数据，如果是最后一行末尾就返回false，不是就返回true。但是next()的主要作用还是游标向下移动一行。

3、获取数据

// 游标默认在第一行之前

举例参见代码：

public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            //1. 注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=gbk&useSSL=false","root","密码");
            //3.定义sql
            String sql = "select * from account";
            //4.获取执行sql对象
            stmt = conn.createStatement();
            //5.执行sql
            rs = stmt.executeQuery(sql);
            //6.处理结果
            //6.1让游标向下移动一行,并判断是否为最后一行
            while(rs.next()) {
                //6.2获取数据
                int id = rs.getInt(1);
                String name = rs.getString("name");
                double balance = rs.getDouble(3);
                System.out.println(id + "---" + name + "---" + balance);

            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

5. PreparedStatement：执行sql对象

1、SQL注入问题：

① 用户随便输入，输入密码：a' or 'a' = 'a

② sql：select * from user where username = 'dhfiu' and passworld = 'a' or 'a' = 'a'

2、解决sql注入问题，使用PreparedStatement

3、预编译：参数使用？作为占位符

4、步骤：

① 导入驱动jar包

② 注册驱动

③ 获取数据库连接对象 Connection

④ 定义sql

* 注意sql的参数使用？作为占位符。如select * from user where username = ？and pass world = ？;

⑤ 获取执行sql语句的对象 PreparedStatement Connection.PreparedStatement(String sql)

⑥ 给？赋值：

* 方法：setXxx(参数1，参数2)

参数1：？的位置编号从1开始

参数2：？的值

⑦ 执行sql：接受返回结果，不需要传递sql语句

⑧ 处理结果

⑨ 释放资源

抽取JDBC工具类 JDBCUtils

我们在写这些代码的时候会发现，代码的复用性很大，我们可以写一个工具类来方便以后的开发。

分析：

1、抽出注册驱动

2、抽取一个方法获取连接对象

不传递参数也保证工具类的通用性，可以使用配置文件，如果需要改变用户修改配置文件就好了

配置文件：jdbc.properties

url = 路径

user = 用户名

passworld = 密码

driver = com.mysql.jdbc.Driver

3、抽取一个方法释放资源

3.1、执行增删改语句时释放Statement和Connection

3.2、执行查询语句时需要释放三个对象Statement、Connection和ResultSet


/**
 * JDBC工具类
 */
public class JDBCUtils {

    private static String url;
    private static String user;
    private static String password;
    private static String driver;

    /**
     * 文件的读取只需要读取一次，使用静态代码块
     */
    static {
        //读取资源文件，获取值
        try {
            //1.创建properties集合类
            Properties pro = new Properties();
            //获取src路径下的文件的方式--->使用classloader 类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL res = classLoader.getResource("jdbc.properties");
            String path = res.getPath();
            System.out.println(path);
            //2.加载文件
            pro.load(new FileReader(path));
            //3.获取属性，赋值
            JDBCUtils.url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            //4.注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接
     * @return 连接对象
     */
    public static Connection getConnection() throws SQLException {

        return DriverManager.getConnection(url,user,password);
    }
    /**
     * 释放资源
     * @param stmt
     * @param conn
     */
    public static void close(Statement stmt,Connection conn) {
        if(stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 释放资源
     * @param rs
     * @param stmt
     * @param conn
     */
    public static void close(ResultSet rs, Statement stmt, Connection conn) {
        if(rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

使用JDBC控制事务

事务：将多个步骤封装，要么都执行成功，要么都执行失败。
操作：

① 开启事务
② 提交事务
③ 回滚事务
使用Connection对象来管理事务
- 开启事务：SetAutoCommit(Boolean autocommit)：
  调用该方法设置参数为false，即为开启事务
  在执行sql之前开启事务，方便下面代码出现异常后回到这儿。
- 提交事务：commit()
  当所有sql都执行完提交事务
- 回滚事务：rollback()
  当遇到异常时，开启事务至发生异常的那一段就会被返回，也就是说，数据库回到开启事务的那一时刻。所以回滚事务就需要在catch中回滚。

代码举例：

public class JDBCAffair {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps1 = null;
        PreparedStatement ps2 = null;
        try {
            //1.注册驱动
            conn = JDBCUtils.getConnection();
            //开启事务
            conn.setAutoCommit(false);
            //2.定义sql语句
            String sql1 = "update account set balance = balance - ? where name = ?";
            String sql2 = "update account set balance = balance + ? where name = ?";
            //3.获取执行sql对象
            ps1 = conn.prepareStatement(sql1);
            ps2 = conn.prepareStatement(sql2);
            //4.设置参数
            ps1.setInt(1,500);
            ps1.setString(2,"lisi");
            ps2.setInt(1,500);
            ps2.setString(2,"qianer");
            //5.执行语句
            ps1.executeUpdate();
            ps2.executeUpdate();
            conn.commit();
        } catch (Exception e) {      //这儿的SQLException被改为了范围大的Exception，否则抓到的异常可能不进入这儿，这样就可能不会回滚了。
            //事务回滚
            try {
                conn.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }
        //使用工具类释放资源
        JDBCUtils.close(ps1,conn);
        JDBCUtils.close(ps2,null);
    }
}

执行前：所有人的平均薪水都是1000