JAVA——JDBC学习

视频连接:https://www.bilibili.com/video/BV1sK411B71e/?spm_id_from=333.337.search-card.all.click&vd_source=619f8ed6df662d99db4b3673d1d3ddcb

《视频讲解很详细!!推荐》

JDBC(Java DataBase Connectivity Java数据库连接)

栗子:类比USB

1. 概述⛺

出现原因

  • 在Java中提供对数据库的访问支持,便于软件开发过程中使用数据库来存储和管理数据
  • 如果用户直接操作数据库,数据库种类变化之后,代码改动量很大。JDBC由各数据库厂商按照统一的规范提供数据库驱动(JDBC实现类),可以操作所有的关系型数据库,减少了用户和底层数据库的交互,增强了代码的通用性。

推行

SUN公司于1996年提供访问数据库的标准Java类库

原理

JAVA——JDBC学习_第1张图片

步骤

  • 步骤1:java.sql.* JDBC接口 对象 = 第三方实现类实例;(JDBC API主要位于java.sql包中,该包定义了一系列访问数据的接口和类)
  • 步骤2:对象.jdbc标准方法();

组成

  • Java提供的jdbc规范(接口,多态,面向接口编程)
  • 各个数据库厂商的实现驱动jar包

2. JDBC技术组成

2.0 使用步骤

0)准备数据库

mysql> create table t_user(
    -> id int primary key auto_increment comment '用户主键',
    -> account varchar(20) not null unique comment '账户',
    -> password varchar(64) not null comment '密码',
    -> nickname varchar(20) not null comment '昵称');
    
 insert into t_user(account, password, nickname) values ('root', '123456', '经理'), ('admin', '666666', '管理员');

1)注册驱动:安装jar包,注册了之后Java就允许远程数据库的连接了

2)获取连接:建立java程序和数据库软件的通道

3)创建发送sql语句对象:sql语句的载体

4)发送sql语句,并获取返回结果:载体发送sql到数据库,并获取返回结果,得到一个结果对象

5)结果集解析:把结果对象拆出来

6)资源关闭:销毁资源,关闭连接,关闭载体,释放结果对象

2.1 DriverManager

作用

  • 将第三方数据库厂商的实现驱动jar注册到程序中
  • 可以根据数据库的连接信息获取Connection

2.2 Connection

作用

  • 和数据库建立连接,在连接对象上,可以多次执行数据库操作
  • 可以获得下面2.3节的三类对象

2.3 Statement | PreparedStatement | CallableStatement

1)Statement:静态SQL路线(没有动态值语句,也就是没有条件的)

/*
使用statement查询t_user表下,全部数据
 */
public class StatementQueryPart {
    public static void main(String[] args) throws SQLException {
        // 1. 注册驱动
        DriverManager.registerDriver(new Driver());
        // 2. 获取连接
        // 参数1:url——jdbc:数据库厂商名://ip地址:port/数据库名
        // java.sql 接口 = 实现类
        Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test", "xy", "123456");
        // 3. 创建发送sql语句的对象 Statement
        Statement statement = connection.createStatement();
        // 4. 发送sql语句并返回结果集
        String sql = "select * from t_user;";
        ResultSet resultSet = statement.executeQuery(sql);
        // 5. 解析结果
        // next是看看下一行有没有数据,有的话就取,没有的话就退出了。它初始指的位置是指向字段的
        while (resultSet.next()) {
            int id = resultSet.getInt("id");
            String account = resultSet.getString("account");
            String password = resultSet.getString("password");
            String nickname = resultSet.getString("nickname");
            System.out.println("id:" + id + " | " + "account: " + account + " | " + "password: " + password + " | " + "nickname: " + nickname);
        }
        // 6. 资源关闭
        resultSet.close();
        statement.close();
        connection.close();
    }
}


/* 
结果
id:1 | account: root | password: 123456 | nickname: 经理
id:2 | account: admin | password: 666666 | nickname: 管理员
*/
// 详细知识!!
public class StatementUserLoginPart {
    public static void main(String[] args) throws Exception {
        // 1. 键盘输入事件
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入账号:");
        String account = sc.nextLine();
        System.out.print("请输入密码:");
        String password = sc.nextLine();

        // 2. 注册驱动
        // DriverManager.registerDriver(new Driver());  // 问题:注册两次驱动(方法本身注册一次,new对象里面有静态代码块也会注册一次),性能消耗
        // 改进:只触发静态代码块——类加载的时候1)new关键字;2)调用静态方法;3)调用静态属性;4)接口default默认实现;5)反射;6)子类出发父类;7)程序入口main
        // new Driver();
        // 反射:字符串参数提取到外部配置文件——>灵活
        Class.forName("com.mysql.cj.jdbc.Driver");

        // 3. 获取数据库连接
        // 如果本机并且端口是3306,url可以简写jdbc:mysql:///test
        // 三个参数
        // Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test", "xy", "123456");
        // 两个参数
        // Properties info = new Properties();
        // info.put("user", "xy");
        // info.put("password", "123456");
        // Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test", info);
        // 一个参数
        // jdbc:mysql://***.***.***.***:3306/test?user=xy&password=123456
        Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test?user=xy&password=123456");

        // 4. 创建发送sql语句的Statement对象
        Statement statement = connection.createStatement();

        // 5. 发送sql并返回结果集
        String sql = "select * from t_user where account = '"+ account + "'and password = '" + password + "';";
        // 非DQL int row = executeUpdate(sql) ;  DML影响的行数,其他就是返回0
        // ResultSet resultSet = statement.executeQuery(sql); 返回的是结果封装对象
        ResultSet resultSet = statement.executeQuery(sql);

        // 6. 查询结果集的解析
//        while (resultSet.next()) {
//            int id = resultSet.getInt(1);
//            String account1 = resultSet.getString("account");
//            String password1 = resultSet.getString(3);
//            String nickname = resultSet.getString("nickname");
//            System.out.println("id:" + id + " | " + "account: " + account1 + " | " + "password: " + password1 + " | " + "nickname: " + nickname);
//        }

        // 检查是否登录成功
        if (resultSet.next()) {
            System.out.println("登录成功啦!") ;
        } else {
            System.out.println("啊哦~~失败咯~");
        }

        // 7. 关闭资源
        resultSet.close();
        statement.close();
        connection.close();
    }
}

存在的问题:

  • SQL语句需要字符串拼接,比较麻烦
  • 只能拼接字符串类型,其他的数据库类型无法处理
  • 可能发生注入共计——动态值充当了SQL语句结构,影响了原有的查询结果

2)PreparedStatement:预编译SQL路线(有动态值语句)——常用

public class PSUserLoginPart {
    public static void main(String[] args) throws Exception {
        // 1. 键盘输入事件
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入账号:");
        String account = sc.nextLine();
        System.out.print("请输入密码:");
        String password = sc.nextLine();

        // 2. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

        // 3. 获取连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test?user=xy&password=123456");

        // 4. 编写SQL语句
        String sql = "select * from t_user where account = ? and password = ? ;";
        // 创建预编译statement并设置SQL语句结果
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        // 单独的占位符赋值
        // 第一个参数是index占位符的位置,从左往由从1开始;第二个参数是object占位符的值,可以设置任何类型的数据,避免了拼接和类型更加丰富!
        preparedStatement.setObject(1, account);
        preparedStatement.setObject(2, password);

        // 5. 发送SQL语句,并获取返回结果
        ResultSet resultSet = preparedStatement.executeQuery();  // 不需要传递参数,因为已经知道sql语句并且获得了动态值

        // 6. 结果集解析
        if (resultSet.next()) {
            System.out.println("登录成功啦!") ;
        } else {
            System.out.println("啊哦~~失败咯~");
        }

        // 7. 关闭资源
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}
// 更加灵活地取到结果集对象
public class PSCURDPart {
    public static void main(String[] args) throws Exception {
        // 目标:查询tb_user表中的数据,更加灵活地取到结果集对象
        // 1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        // 2. 获取连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test?user=xy&password=123456");
        // 3. 获取创建sql语句的对象
        String sql = "select id, account, password, nickname from t_user";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        // preparedStatement.setObject();  // 给占位符赋值,这里没有使用占位符,所以不进行赋值操作
        // 4. 将sql语句发送到数据库并返回结果集
        ResultSet resultSet = preparedStatement.executeQuery();
        // 5. 解析结果集的对象
        /* 一般情况
        while (resultSet.next()){
            int id = resultSet.getInt("id");
        }
        存在的问题
        要手动获取列名——>我们就要知道由哪些列,不智能
        万一列名修改了——>代码这里也要进行相应的修改,不通用
        */
        // metaData 可以获取列的名称,也可以获取列的数量
        ResultSetMetaData metaData = resultSet.getMetaData();
        // 获取列的数量
        int columnCount = metaData.getColumnCount();
        List<Map> list = new ArrayList<>();
        while(resultSet.next()) {
            Map map = new HashMap();
            for (int i = 1; i <= columnCount; i++) {
                // 根据下角标获取值
                Object value = resultSet.getObject(i);
                // 获取指定下角标的列名
                String key = metaData.getColumnLabel(i);  // 会获取列的别名
                map.put(key, value);
            }
            list.add(map);
        }
        System.out.println(list);

        // 6. 释放资源
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}

3)CallableStatement:执行标准存储过程SQL路线(有存储过程的)

2.4 Result

作用

  • 数据库的查询结果表
  • 存储DQL查询数据库结果的对象
  • 需要我们进行解析,获取具体的数据库数据

3. 提升扩展️

3.1 自增长主键回显实现

获取数据库自增长的主键——主键回显

给关联的子表插入的时候使用

public class PSOtherPart {
    // 创建prepareStatement的时候添加一个参数Statement.RETURN_GENERATED_KEYS
    // 解析结果集的时候Statement.getGeneratedKeys()返回ResultSet
    @Test
    public void returnPrimaryKey() throws Exception {
        // 1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        // 2. 获取连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test?user=xy&password=123456");
        // 3. 创建statement
        String sql = "insert into t_user(account, password, nickname) values (?, ?, ?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
        preparedStatement.setObject(1, "test1");
        preparedStatement.setObject(2, "123456");
        preparedStatement.setObject(3, "嘎嘎嘎");
        // 4. 发送sql语句并获取结果
        int row = preparedStatement.executeUpdate();
        // 5. 解析结果
        if(row > 0) {
            System.out.println("数据插入成功");
            ResultSet resultSet = preparedStatement.getGeneratedKeys();
            resultSet.next();
            int id = resultSet.getInt(1);
            System.out.println("主键值是:" + id);
        } else{
            System.out.println("数据插入失败");
        }
        // 6. 关闭资源
        preparedStatement.close();
        connection.close();
    }
}

3.2 批量数据插入性能提升

1)url?rewriteBatchedStatements=true

2)statement.addBatch(); // 不执行,追加到values后面

3)statement.executeBatch(); // 执行批量操作

4)insert语句后面不加分号结束

@Test
public void testInsert() throws Exception {
    // 批量插入
    // 一般:插入的时候循环
    // 优化:批量
    // url?rewriteBatchedStatements=true
    // statement.addBatch();  // 不执行,追加到values后面
    // statement.executeBatch();  // 执行批量操作
    // 1. 注册驱动
    Class.forName("com.mysql.cj.jdbc.Driver");
    // 2. 获取连接
    Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test?rewriteBatchedStatements=true", "xy", "123456");
    // 3. 创建statement
    String sql = "insert into t_user(account, password, nickname) values (?, ?, ?)";  // 批量的话sql不能加;结束
    PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
    for (int i = 100; i < 110; i++) {
        preparedStatement.setObject(1, "test1" + i);
        preparedStatement.setObject(2, "123456" + i);
        preparedStatement.setObject(3, "嘎嘎嘎" + i);
        preparedStatement.addBatch();  // 追加
    }
    preparedStatement.executeBatch();  // 统一批量执行
    // 4. 发送sql语句并获取结果
    // 5. 解析结果
    // 6. 关闭资源
    preparedStatement.close();
    connection.close();
}

3.3 jdbc中数据库事务实现

事务的最基础要求是:必须是同一个连接对象 connection

业务里面开启事务

步骤:

  • 事务添加是在业务方法中
  • 利用try catch,开启事务,提交事务和事务回滚
  • 将connection传入方法中,方法中就不需要close了

业务方法

public class BankService {
    @Test
    public void testtransfer() throws Exception {
        transfer("ergouzi", "lvdandan", 50);
    }


    public void transfer(String addAccount, String subAccount, int money) throws Exception {
        // 1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        // 2. 获取连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://***.***.***.***:3306/test?user=xy&password=123456");        BankDao bankDao = new BankDao();

        try {
            // 开启事务
            // 关闭事务提交
            connection.setAutoCommit(false);
            // 执行
            bankDao.add(addAccount, money, connection);
            System.out.println("-----");
            bankDao.sub(subAccount, money, connection);
            // 事务提交
            connection.commit();
        } catch (Exception e){
            // 事务回滚
            connection.rollback();
            // 抛出异常
            throw e;
        } finally {
            connection.close();
        }
    }
}

实现方法

public class BankDao {
    // 加钱
    public void add(String account, int money, Connection connection) throws Exception {
        // 3. 创建statement
        String sql = "update t_bank set money = money + ? where account = ?;";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        // 4. 给占位符赋值
        preparedStatement.setObject(1, money);
        preparedStatement.setObject(2, account);
        // 5. 发送SQL语句
        preparedStatement.executeUpdate();
        // 6. 关闭资源
        preparedStatement.close();

        System.out.println("加钱成功");
    }

    // 减钱
    public void sub(String account, int money, Connection connection) throws Exception {
        // 3. 创建statement
        String sql = "update t_bank set money = money - ? where account = ?;";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        // 4. 给占位符赋值
        preparedStatement.setObject(1, money);
        preparedStatement.setObject(2, account);
        // 5. 发送SQL语句
        preparedStatement.executeUpdate();
        // 6. 关闭资源
        preparedStatement.close();

        System.out.println("减钱成功");

    }
}

4. Druid连接池技术使用

4.1 连接性能消耗问题分析

connection可以复用!!容器池——节约了创建和销毁连接的性能消耗,提升了时间的响应

4.2 数据库连接池作用

  • 连接池可以存储一定数量的连接对象
  • 用户要的时候就直接拿,拿完再放回去
  • 池子李的连接都用完了,可以向服务器申请新的连接放到池子里
  • 池中的连接达到最大连接数的时候,就不能申请新的连接了,等等嗷

4.3 市面常见连接池产品和对比

javax.sql.DataSource接口

  • 规范了连接池获取连接的方法
  • 规范了连接池回收连接的方法

DataSource = 第三方连接池的实现

选择考虑

  • 性能优势
  • 性能扩展

4.4 druid连接池使用

硬编码

public class DruidUsePart {

    /*
    * 直接使用代码设置连接池连接参数
    * 1. 创建一个druid连接池对象
    * 2. 设置连接池参数 [必须 | 非必须]
    * 3. 获取连接 [通用方法,所有连接池都一样]
    * 4. 回收连接 [通用方法,所有连接池都一样]
    * */
    public void testHard() throws Exception {
        // 连接池对象
        DruidDataSource dataSource = new DruidDataSource();
        // 设置参数
        // 必须 注册驱动 | url | user| password
        dataSource.setUrl("jdbc:mysql://***.***.***.***:3306/test");
        dataSource.setUsername("xy");
        dataSource.setPassword("123456");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");  // 驱动注册和获取连接
        // 非必须 初始化连接数量,最大的连接数量……
        dataSource.setInitialSize(5); // 初始化连接数量
        dataSource.setMaxActive(10);  // 最大的数量

        // 获取连接
        Connection connection = dataSource.getConnection();
        // 数据库
        // 回收连接
        connection.close();
    }
}

软编码

// 软连接:通过读取外部配置文件的方法,实例化druid连接池对象
@Test
public void testSoft() throws Exception {
    // 1. 读取外部配置文件 Properties
    Properties properties = new Properties();
    // src下的文件,可以使用类加载器提供的方法
    InputStream ips = DruidUsePart.class.getClassLoader().getResourceAsStream("druid.properties");
    properties.load(ips);

    // 2. 使用连接池工具类的工程模式,创建连接池
    DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
    Connection connection = dataSource.getConnection();
    // 中间做数据库curd
    connection.close();
}

避免每次重复代码,实现工具类

需求:内部包含一个连接池对象,并对外提供获取连接和回收连接的方法!

工具类

// 内部包含一个连接池对象,并对外提供获取连接和回收连接的方法!
/*
* 属性:连接池对象【实例化一次】
* 方法:
*       对外提供连接的方法
*       回收外部传入连接方法
* */
public class JdbcUtils {
    private static DataSource dataSource = null;  // 连接池对象
    static {
        // 初始化连接池对象
        // 1. 读取外部配置文件 Properties
        Properties properties = new Properties();
        // src下的文件,可以使用类加载器提供的方法
        InputStream ips = DruidUsePart.class.getClassLoader().getResourceAsStream("druid.properties");
        try {
            properties.load(ips);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            // 2. 使用连接池工具类的工程模式,创建连接池
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws Exception {
        return dataSource.getConnection();
    }

    public static void freeConnection(Connection connection) throws Exception {
        connection.close();
    }
}

测试

public class JdbcCrudPart {
    public void testInsert() throws Exception {
        Connection connection = JdbcUtils.getConnection();
        // 数据库curd动作
        JdbcUtils.freeConnection(connection);
    }
}

基于以上部分的思考:在事务中,需要保证整个事务都是一个连接。之前的做法是在业务类中创建连接,在调用实际方法的时候,将连接作为参数传递——>增加参数传递这个步——>实质:保证同一线程的方法使用同一个连接——>将连接保存在这个本地线程对象中,执行的时候确定一下这个本地线程对象中的连接

做法:全局声明一个线程本地对象

​ 工具类中判断线程本地对象中的连接是否存在

public class JdbcUtilsV2 {
    private static DataSource dataSource = null;  // 连接池对象
    // 线程本地对象***
    private static ThreadLocal<Connection> tl = new ThreadLocal<>();
    static {
        // 初始化连接池对象
        // 1. 读取外部配置文件 Properties
        Properties properties = new Properties();
        // src下的文件,可以使用类加载器提供的方法
        InputStream ips = DruidUsePart.class.getClassLoader().getResourceAsStream("druid.properties");
        try {
            properties.load(ips);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            // 2. 使用连接池工具类的工程模式,创建连接池
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws Exception {
        // 查看线程本地变量中是否存在
        Connection connection = tl.get();
        // 判断有没有
        if (connection == null) {
            connection = dataSource.getConnection();
            tl.set(connection);
        }
        return connection;
    }

    public static void freeConnection() throws Exception {
        // 看看线程本地变量中有没有这个连接
        Connection connection = tl.get();
        if (connection != null) {
            tl.remove();  // 情况线程本地变量
            connection.setAutoCommit(true);  // 事务状态回归
            connection.close();
        }

    }
}

5. baseDao

5.1 baseDo概念

Dao:每一个数据表对应的DAO接口及其实现类,实现对数据表的增删改查

DaoseDao:Dao实现类中重复度很高的代码抽象成的公共父类

5.2 非DQL方法封装

public class BaseDao {
    public static int executeUpdate(String sql, Object...parms) throws Exception {
        // 获取连接
        Connection connection = JdbcUtilsV2.getConnection();
        // 创建statement
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        for (int i = 1; i <= parms.length; i++) {
            preparedStatement.setObject(i, parms[i-1]);
        }
        // 发送sql语句
        int rows = preparedStatement.executeUpdate();

        // 关闭连接-要看这里是否是事务中的连接,如果是事务里面的,后面可能还会用,就不关闭连接;否则关闭连接
        if (connection.getAutoCommit()) {
            // 没事务
            JdbcUtilsV2.freeConnection();
        }
        return rows;
    }
}

调用一下

@Test
public void testInsert() throws Exception {
    String sql = "insert into t_user(account, password, nickname) values (?, ?, ?)";  // 批量的话sql不能加;结束
    executeUpdate(sql, "测试1", "1234", "222");
    System.out.println("执行成功!");
}

执行之后,数据库内插入成功了,但是报错如下:信息: {dataSource-1} inited

JAVA——JDBC学习_第2张图片

Debug——配置文件是否有问题

JAVA——JDBC学习_第3张图片

大no特no——这不是出现问题了(还改了一大堆)

在这里插入图片描述

参考连接:https://wenku.csdn.net/answer/55db899163e9498f8c36d2ff9b8d8504

5.3 DQL查询方式封装

public <T> List<T> executrQuery(Class<T> clazz, String sql, Object... params) throws Exception {
    // 获取连接
    Connection connection = JdbcUtilsV2.getConnection();
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    // 动态值
    if (params != null && params.length != 0) {
        for (int i = 1; i <= params.length; i++) {
            preparedStatement.setObject(i, params[i-1]);
        }
    }
    // 发送sql
    ResultSet resultSet = preparedStatement.executeQuery();
    // 结果集解析
    List<T> list = new ArrayList<>();
    ResultSetMetaData metaData = resultSet.getMetaData();
    int columnCount = metaData.getColumnCount();
    while (resultSet.next()) {
        T t = clazz.newInstance();  // 调用类的无参构造函数实例化对象
        for (int i = 1; i <= columnCount; i++) {
            Object value = resultSet.getObject(i);
            String propertyName = metaData.getColumnLabel(i);
            // 反射——给赋值
            Field field = clazz.getDeclaredField(propertyName);
            field.setAccessible(true);  // 防止私有的不能赋值
            field.set(t, value);
        }
        list.add(t);
    }
    // 关闭资源
    resultSet.close();
    preparedStatement.close();
    if (connection.getAutoCommit()) {
        JdbcUtilsV2.freeConnection();
    }
    return list;
}

问题:

这里应该如何传参?——试了好多,希望学到更多知识的时候能回来解决

总结

JAVA——JDBC学习_第4张图片

你可能感兴趣的:(JAVA基础篇,#,JDBC,java,mysql,数据库)