JDBC学习笔记

JDBC学习笔记一、基础概念：

JDBC定义了操作所有关系型数据库的规则(接口)
每个数据库厂商提供自己数据库的实现类（数据库驱动）
JDBC本质：

本质其实是（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口(JABC)编程，真正执行的代码是驱动jar包中的实现类

二、快速入门入门代码示例：

public class JdbcDemo1 {
    public static void main(String[] args) throws Exception {
//        1.导入驱动jar
//        2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
//        3.获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/student", "root", "123456");
//        4. 定义sql语句
        String sql = "update student set age = 11 where id = 1";
//        5. 获取执行sql语句的对象 Statement
        Statement stmt = conn.createStatement();
//        6. 执行sql语句
        int count = stmt.executeUpdate(sql);
//        7. 打印处理结果
        System.out.println(count);
//        8. 释放资源
        stmt.close();//释放执行sql语句的对象
        conn.close();//释放连接数据库的对象
    }
}

规范化代码：

处理异常
释放资源
判断结果

public class JDBCDemo2 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try {
//              1. 注册驱动
            Class.forName("com.mysql.jdbc.Driver");
//              2. 获取数据库连接对象
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/student", "root", "123456");
//              3. 定义sql语句
            String sql = "insert into student value(null,'K',10)";
//              4. 获取执行sql的对象
            stmt = conn.createStatement();
//              5. 执行sql语句
            int count = stmt.executeUpdate(sql);//影响的行数
            System.out.println(count);//打印
//              6. 处理结果
            if(count > 0){
                System.out.println("添加成功！");
            }else{
                System.out.println("添加失败！");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            if(stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

步骤：

1. 导入mysql的驱动jar包

jar包名：mysql-connector-java-5.1.37-bin.jar
复制 mysql-connector-java-5.1.37-bin.jar 到项目的libs目录下(方便管理工具包)
在项目中对包点击右键–>Add as Library(真正将jar包加入项目工作空间中)

2. 注册驱动

Class.forName("com.mysql.jdbc.Driver");

3. 获取数据库连接对象Connection

4. 定义sql字符串存储sql语句

5. 获取执行sql语句的对象Statement

6. 执行sql语句，接受返回结果

7. 处理结果

8. 释放资源

三、 JDBC中的各个类和接口详解 1. DriverManager: 数据库驱动管理对象 ①、注册驱动 1. 作用:

告诉程序应该用哪个数据库的驱动jar包

static void registerDriver(Driver driver)方法: 注册与给定的驱动程序 DriverManager

写代码则使用：Class.forName(“com.mysql.jdbc.Driver”); 加载名为com.mysql.jdbc.Driver的类进内存

com.mysql.jdbc.Driver包中的Driver类中写了静态代码块，调用了registerDriver()方法，从而实现了驱动注册

static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
}

2. 注意事项：

mysql 5 之后可以不用写注册驱动语句，因为jar包提供了一个java.mysql.Driver文件，里面写了类名com.mysql.jdbc.Driver，所以如果没有写注册驱动语句，则jar包会自动读取文件中的类名自动注册驱动。

所以mysql 5 之后的驱动jar包可以省略注册驱动的步骤

②、连接数据库

方法：static Connection``getConnection(String url, String user, String password)

参数：

url:指定连接的数据库路径

//        3.获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/student", "root", "123456");

语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
例子：jdbc:mysql://localhost:3306/student
拓展：如果连接的是本机的mysql服务器，并且mysql服务器默认端口是3306，则url可以简写为：jdbc:mysql:///student

user:数据库用户名
password:数据库密码

2.Connection:数据库连接对象 1. 功能： ①、获取执行sql语句的对象

Statement creatStatement()
PrepareStatement prepareStatement(String sql)

②、管理事务

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

将此连接的自动提交模式设置为给定状态
提交事务：commit()

使自上次提交/回滚以来所做的所有更改都将永久性，并释放此 Connection对象当前持有的任何数据库锁
回滚事务：void rollback()

撤消在当前事务中所做的所有更改，并释放此 Connection对象当前持有的任何数据库锁

3.Statment:执行sql语句的对象 1. 执行sql ①、（了解）boolean execute(String sql) 方法:

作用：

执行此 Statement对象中的任意SQL语句
返回值：

true：如果第一个结果是一个ResultSet对象;

false：如果第一个结果是更新计数或没有结果

②、int executeUpdate(String sql) 方法:

作用：

执行DML(insert、update、delete)语句（常用，修改表的数据）

执行DDL(creat,alter,drop)语句（不常用，因为表的结构设计一般在数据库中自己定义好了）
返回值：

操作影响的行数,可以通过这个影响的行数来判断DML语句是否执行成功，返回值大于0，则代表成功，反之则失败

③、ResultSet executeQuery()方法：

作用：

执行DQL(select)查询语句
返回值：

一个包含查询产生的数据的ResultSet对象；从不null;

4.ResultSet：结果集的对象，查询的结果

①、boolean next()方法：将光标从当前位置向下移动一行

返回值：

如果新的当前行有效，则返回true，此时游标还没有到达最后一行的末尾

如果新的当前行无效，则返回false,此时游标在最后一行之后的一行

②、Xxx getXxx()方法：获取相应数据类型的数据

有方法重载：如：int getInt(参数)方法 String getString(参数)

int getInt(int columnIndex) 根据列的编号获取，编号从1开始，如getInt(3)
int getInt(String columnLabel) 根据列的名称获取,如getInt(“age”)

常用写法：
  int rs = stmt.executeQuery(sql);
  while(rs.next()){//当没有达到最后一行的末尾时
    int age = rs.getInt("age");
    System.out.println(age);
  }

③、将查询返回的结果数据封装成JSON对象(重点)：任务：将数据库中的student表中数据封装成JSON对象

数据库中的表：

库名称：student 表名称：student

实现代码：

student.class

package cn.itcast.doamin;

public class student {
    private String name;
    private int age;
    private int id;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public int getId() {
        return id;
    }

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

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

JDBCDemo6.class

package cn.itcast.jdbc;

import cn.itcast.doamin.student;

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

public class JDBCDemo6 {
    
    public static void main(String[] args) {
//        根据类JDBCDemo6，创建一个对象并调用其中的findAll()方法获取student数据
        List list = new JDBCDemo6().findAll();
        System.out.println(list);
    }

    
    public List findAll() {
        List list = null;//声明一个List，存放student对象
        student stu = null;//声明student类的引用
        Connection conn = null;
        Statement stmt = null;
        ResultSet res = null;
        try {
//           1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
//           2、获取数据库连接对象
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/student", "root", "123456");
//           3、定义sql语句
            String sql = "select * from student";
//           4、获取sql语句执行对象
            stmt = conn.createStatement();
//           5、执行sql语句
            res = stmt.executeQuery(sql);
//           6、遍历结果集中的对象,封装对象，装载集合
//            创建list对象
            list = new ArrayList();
            while (res.next()) {
                int id = res.getInt("id");
                String name = res.getString("name");
                int age = res.getInt("age");
//           6.1、创建一个student对象
                stu = new student();
//           6.2、给student对象赋值
                stu.setId(id);
                stu.setName(name);
                stu.setAge(age);
//           6.3、将student对象存放到list中,装载集合
                list.add(stu);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
//            7、释放资源
            if (res != null) {
                try {
                    res.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();
                }
            }
        }
//      8、返回封装好的list
        return list;
    }
}

控制台输出

"C:Program FilesJavajdk-13.0.2binjava.exe" "-javaagent:D:IntelliJ IDEA 2021.2.1libidea_rt.jar=1989:D:IntelliJ IDEA 2021.2.1bin" -Dfile.encoding=UTF-8 -classpath "D:IDEA 工作间itcastoutproductionjdbc;D:IDEA 工作间itcastjdbclibsmysql-connector-java-5.1.37-bin.jar" cn.itcast.jdbc.JDBCDemo6
[student{name='Kevin', age=100, id=1}, student{name='K', age=100, id=2}, student{name='K', age=10, id=20}, student{name='K', age=10, id=21}, student{name='K', age=10, id=22}, student{name='K', age=10, id=23}, student{name='K', age=10, id=24}, student{name='K', age=10, id=25}, student{name='K', age=10, id=26}, student{name='K', age=10, id=27}, student{name='K', age=10, id=28}, student{name='K', age=10, id=29}]

Process finished with exit code 0

四、抽取JDBC工具类：JDBCUtils 1. 目的：简化书写 2. 分析：

①、注册驱动也需要抽取

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

需求：不想传递参数（比较麻烦），还需要保证工具类的通用性
解决：配置文件

文件名：jdbc.prrperties

路径：src目录下

内容：
url=jdbc:mysql://localhost:3306/student
user=root
password=123456
driver=com.mysql.jdbc.Driver

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

3. 项目目录结构：

4. 实现代码： ①、抽取的JDBCUtils工具类：

package cn.itcast.utils;

import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.sql.*;
import java.util.Properties;

public class JDBCUtils {
    //    只有静态变量才能够被静态代码块和静态方法访问
    private static String url;
    private static String user;
    private static String password;
    private static String driver;

    
    static {
//    读取配置文件的内容
        try {
            


//          


//          给类的成员变量赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
//          注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    
    public static Connection getConnection() throws SQLException {
//        常用写法为配置文件获取mysql配置好的参数
        return DriverManager.getConnection(url, user, password);
    }

    
    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();
            }
        }
    }

    public static void close(ResultSet res, Statement stmt, Connection conn) {
        if (res != null) {
            try {
                res.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();
            }
        }
    }
}

②、定义了封装数据库数据的测试类JDBCDemo6:

package cn.itcast.jdbc;

import cn.itcast.doamin.student;
import cn.itcast.utils.JDBCUtils;

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

public class JDBCDemo6 {
    
    public static void main(String[] args) {
//        根据类JDBCDemo6，创建一个对象并调用其中的findAll()方法获取student数据
        List list = new JDBCDemo6().findAll2();
        System.out.println(list);
    }

    
    public List findAll2() {
        List list = null;//声明一个List，存放student对象
        student stu = null;//声明student类的引用
        Connection conn = null;
        Statement stmt = null;
        ResultSet res = null;
        try {
           1、注册驱动
//            Class.forName("com.mysql.jdbc.Driver");
           2、获取数据库连接对象
//            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/student", "root", "123456");
            //替换成：
            conn = JDBCUtils.getConnection();
//           3、定义sql语句
            String sql = "select * from student";
//           4、获取sql语句执行对象
            stmt = conn.createStatement();
//           5、执行sql语句
            res = stmt.executeQuery(sql);
//           6、遍历结果集中的对象,封装对象，装载集合
//            创建list对象
            list = new ArrayList();
            while (res.next()) {
                int id = res.getInt("id");
                String name = res.getString("name");
                int age = res.getInt("age");
//           6.1、创建一个student对象
                stu = new student();
//           6.2、给student对象赋值
                stu.setId(id);
                stu.setName(name);
                stu.setAge(age);
//           6.3、将student对象存放到list中,装载集合
                list.add(stu);
            }

        }  catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
//            7、释放资源
//            替换成：
            JDBCUtils.close(res,stmt,conn);
//            if (res != null) {
//                try {
//                    res.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();
//                }
//            }
        }
//      8、返回封装好的list
        return list;
    }
}

JDBC学习笔记

Java相关栏目本月热门文章