Java学习 - JDBC

GY-93

于 2020-07-29 22:14:34 发布

阅读量193

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/yong_19930826/article/details/107629242

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1. MAC系统IDEA如何使用JDBC链接MySQL

首先创建一个空的项目：打开IDEA->Creat New Project > Empty Project-> 点击next->给项目命名->选择存放的路径-> 点击finish完成
然后下载JDBC驱动
- 官网下载：JDBC下载
- Select Operating Independent 选择 Platform Independent即可。
- 跳转到下载界面界面，如果不想登录直接点击这行小字
点击 File->Project Structure-SDKs
- 点击左下角的 + 号把mysql-connector-java-8.0.21.jar包导入
导入之后看左边的External Libaries中有没有mysql-connector-java-8.0.21.jar
测试下代码，如果一下代码测试成功，就代表导入驱动成功

package com.gy.jdbc.demo1;

public class JdbcDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        /*
            Loading class `com.mysql.jdbc.Driver'. This is deprecated.
            The new driver class is `com.mysql.cj.jdbc.Driver'.
             The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.
         */
        Class.forName("com.mysql.cj.jdbc.Driver");
    }
}

另一种创建JavaWeb的项目，导入JDBC的驱动包:
- 参考链接1
- 参考链接2

2. JDBC中的常用对象

概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库

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

2. 1JDBC快速入门代码

导入mysql-connector-java-8.0.21.jar包到项目
注册驱动
获取数据库连接对象 Connection
定义sql
获取执行sql语句的对象 Statement
执行sql，接受返回结果
处理结果
释放资源

public class JdbcDemo1 {
        public static void main(String[] args) throws ClassNotFoundException {
            /*
                Loading class `com.mysql.jdbc.Driver'. This is deprecated.
                The new driver class is `com.mysql.cj.jdbc.Driver'.
                 The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.
             */
            /*
                注册驱动： 告诉程序该使用哪一个数据库驱动jar包
                查看源码： 在com.mysql.cj.jdbc.Driver类中有一个静态代码块
                static {
                    try {
                            DriverManager.registerDriver(new Driver());
                        } catch (SQLException var1) {
                            throw new RuntimeException("Can't register driver!");
                        }
               }
                实质上是调用DriverManager中的注册驱动的方法

                注意： mysql5之后的驱动jar包可以省略注册驱动的步骤
             */
            Class.forName("com.mysql.cj.jdbc.Driver");


            // mysql连接固定格式： jdbc:mysql://ip地址(域名):端口号/数据库名称
            //如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
            String url = "jdbc:mysql://localhost:3306/db2";
            String user = "root";
            String password = "guoweiyong";
            //数据库的链接对象
            Connection con = null;
            Statement statement = null;
            try {
                //2. 获取数据库的链接
                 /*
                static Connection	getConnection(String url, String user, String password):尝试建立与给定数据库URL的连接。
             */
                con = DriverManager.getConnection(url, user, password);

                //定义sql语句 更新语句
                String sql = "update stu set salary = 50 where name = 'zhangsan';";

                //获取数据库的指向对象
                statement = con.createStatement();

                //然后执行sql语句
                /*
                   boolean execute(): 可以执行任意的sql的语句
                   int	executeUpdate(String sql)：执行给定的SQL语句，这可能是 INSERT ， UPDATE ，或 DELETE语句，或者不返回任何内容，如DML DDL语句的SQL语句。
                 */
                int count = statement.executeUpdate(sql); // 返回值是影响数据库数据的行数
                //处理结果
                System.out.println("count=======" + count);

            } catch (SQLException throwables) {
                throwables.printStackTrace();
            } finally {
                //释放资源
                if (statement != null){
                    try {
                        statement.close();
                    } catch (SQLException throwables) {
                        throwables.printStackTrace();
                    }
                }

                if (con != null) {
                    try {
                        con.close();
                    } catch (SQLException throwables) {
                        throwables.printStackTrace();
                    }
                }
            }
        }
    }

2.2 JDBC中常用对象

1.DriverManager：驱动管理对象
- 注册驱动告诉程序使用哪一个数据库驱动jar包
- static void registerDriver(Driver driver) :注册与给定的驱动程序 DriverManager
- mysql5之后的驱动jar包可以省略注册驱动的步骤。
2.获取数据库的链接
- static Connection getConnection(String url, String user, String password) 尝试建立与给定数据库URL的连接
- 参数：
  - url：指定连接的路径->jdbc:mysql://ip地址(域名):端口号/数据库名称 案例：jdbc:mysql://localhost:3306/db3 ；如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
  - user : 用户名
  - password: 密码
3.Connection:数据库的链接对象：
- 获取执行sql的对象->Statement createStatement();PreparedStatement prepareStatement(String sql)
- 管理事务：
  - 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
  - 提交事务：commit()
  - 回滚事务：rollback()
4.Statement：执行sql的对象:
- boolean execute(String sql) ：可以执行任意的sql语句(了解)
- int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句； 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功返回值>0的则执行成功，反之，则失败。
- ResultSet executeQuery(String sql) ：执行DQL（select)语句
5.ResultSet：结果集对象,封装查询结果
- boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true
- getXxx(参数):获取数据
  - Xxx：代表数据类型如： int getInt() , String getString()
  - 参数：
    - int：代表列的编号,从1开始如： getString(1)
    - String：代表列名称。如： getDouble(“balance”)
- 注意：使用步骤
  - 游标向下移动一行
  - 判断是否有数据
  - 获取数据
案例练习在下面的ResultSet案例
6.PreparedStatement：执行sql的对象:
SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
- 下面登录案例实现就存在着SQL注入问题：当我随便输入一个用户名，密码输入：a’ or ‘a’ = 'a时
- sql：select * from tab_user where userName = ‘fhdsjkf’ and password = ‘a’ or ‘a’ = ‘a’ 会出现登录成功的返回，这显然是不对的
解决sql注入问题：使用PreparedStatement对象来解决
预编译的SQL：参数使用 ? 作为占位符
步骤：
1. 导入驱动 mysql-connector-java-8.0.21.jar包
2. 注册驱动
3. 获取数据库连接对象 Connection
4. 定义sql -> 注意：sql的参数使用？作为占位符。如：select * from user where username = ? and password = ?;
5. 获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
6. 给？赋值：
  - 方法： setXxx(参数1,参数2)
    - 参数1：？的位置编号从1 开始
    - 参数2：？的值
7. 执行sql，接受返回结果，不需要传递sql语句
8. 处理结果
9. 释放资源
注意：后期都会使用PreparedStatement来完成增删改查的所有操作
- 第一可以防止SQL注入造成的问题
- 第二是执行的效率更高
案例：下面登录实现案例（PreparedStatement的运用和ResultSet会出现SQL注入的问题）

2.3 JDBC操作数据库案例练习

需求：emp 表添加一条记录； emp表修改记录； emp表删除一条记录
创建的emp 代码如下：

CREATE TABLE emp (
  id INT PRIMARY KEY, -- 员工id
  ename VARCHAR(50), -- 员工姓名
  job_id INT, -- 职务id
  mgr INT , -- 上级领导
  joindate DATE, -- 入职日期
  salary DECIMAL(7,2), -- 工资
  bonus DECIMAL(7,2), -- 奖金
  dept_id INT, -- 所在部门编号
  CONSTRAINT emp_jobid_ref_job_id_fk FOREIGN KEY (job_id) REFERENCES job (id), -- 员工所在职位 外键ID 
  CONSTRAINT emp_deptid_ref_dept_id_fk FOREIGN KEY (dept_id) REFERENCES dept (id) -- 员工所在部门 
);

Java代码实现：

public class JDBCDemo1 {
    public static void main(String[] args) {
        //1.添加一条信息
//        String sql = "INSERT INTO stu VALUES (NULL,'wangwu',30);";
//        updateDB(sql);

        //2.修改刚才添加的信息
//        String sql1 = "UPDATE stu SET salary = 25 WHERE name = 'wangwu';";
//        updateDB(sql1);

        //3.删除添加的信息
        String sql2 = "DELETE FROM stu WHERE name = 'wangwu';";
        updateDB(sql2);
    }

    public static void updateDB(String sql) {
        Connection con = null;
        Statement statement = null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");

            //2.获取数据库的链接对象
            String url = "jdbc:mysql://localhost:3306/db2";
            String user = "root";
            String password = "guoweiyong";
            con = DriverManager.getConnection(url,user,password);

            //3.获取执行sql对象
            statement = con.createStatement();

            //4执行sql语句，然后处理结果
            int count = statement.executeUpdate(sql);
            System.out.println("count=======" + count);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (con != null) {
                try {
                    con.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

    }
}

2.4 ResultSet案例练习

定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
1. 定义Employee类
2. 定义方法 public List findAll(){}
3. 实现方法 select * from emp;
Employee 示例代码：

public class Empioyee {
    private int id;
    private String ename;
    private int job_id;
    private int mgr;
    private Date joindate;
    private int salary;
    private int bonus;
    private int dept_id;

    public int getId() {
        return id;
    }

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

    public String ename() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public int getJob_id() {
        return job_id;
    }

    public void setJob_id(int job_id) {
        this.job_id = job_id;
    }

    public int getMgr() {
        return mgr;
    }

    public void setMgr(int mgr) {
        this.mgr = mgr;
    }

    public Date getJoindate() {
        return joindate;
    }

    public void setJoindate(Date joindate) {
        this.joindate = joindate;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }

    public int getDept_id() {
        return dept_id;
    }

    public void setDept_id(int dept_id) {
        this.dept_id = dept_id;
    }

    @Override
    public String toString() {
        return "Empioyee{" +
                "id=" + id +
                ", ename='" + ename + '\'' +
                ", job_id=" + job_id +
                ", mgr=" + mgr +
                ", joindate=" + joindate +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", dept_id=" + dept_id +
                '}';
    }
}

执行代码：

public class JDBCDemo2 {
    public static void main(String[] args) {
        List<Empioyee> empioyees = findAll();
        System.out.println("empioyees======" + empioyees);
    }

    public static List<Empioyee> findAll(){
        Statement statement = null;//执行sql语句的对象
        Connection connection = null; //数据库的链接对象
        ResultSet resultSet = null; //返回结果积对象
        List<Empioyee> empioyees = new ArrayList<>();
        try {
            //1.注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");

            //2.获取链接对象
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2","root","guoweiyong");

            //3.获取sql对象
            statement = connection.createStatement();
            String sql = "SELECT * FROM emp;";
            resultSet = statement.executeQuery(sql); //返回查询的结果积

            //读取数据，然后把读取的数据转换成模型
            Empioyee empioyee = null;
            while (resultSet.next()) {
                //进来代表有数据
                int id = resultSet.getInt("id");
                String ename = resultSet.getString("ename");
                int job_id = resultSet.getInt("job_id");
                int mgr = resultSet.getInt("mgr");
                Date joindate = resultSet.getDate("joindate");
                int salary = resultSet.getInt("salary");
                int bonus = resultSet.getInt("bonus");
                int dept_id = resultSet.getInt("dept_id");

                //设置模型的值
                empioyee = new Empioyee();
                empioyee.setId(id);
                empioyee.setEname(ename);
                empioyee.setJob_id(job_id);
                empioyee.setMgr(mgr);
                empioyee.setJoindate(joindate);
                empioyee.setSalary(salary);
                empioyee.setBonus(bonus);
                empioyee.setDept_id(dept_id);

                empioyees.add(empioyee);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

        return empioyees;
    }
}

2.5 JDBC工具类的抽取

分析：
- 注册驱动的抽取
- 抽取一个方法获取链接对象
  - 需求：不需要传递参数，还得保证工具类的通用性
  - 解决方案：使用配置文件 -> jdbc.properties

public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    /*
        文件的读取只需要读取一次，所以我们采用静态代码块
     */
    static {
        //使用Properties对象来加载对象
        Properties properties = new Properties();
        //获取配置文件的内容 获取src路劲下的文件 ->ClassLoader类加载器
        //URL pathUrl = JDBCUtils.class.getClassLoader().getResource("jdbc.properties");
        //得到文件的路径
        //String path = pathUrl.getPath();
        try {
            //properties.load(new FileReader(path));
            //第二种获取资源的方式
            InputStream inputStream = JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            properties.load(inputStream);

            //获取值 然后赋值
            url = properties.getProperty("url");
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            driver = properties.getProperty("driver");

            // 注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取数据库的链接对象
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,user,password);
    }

    /**
     * 释放资源的方法
     * @param statement 释放执行sql语句的对象
     * @param connection 释放连接数据库的对象
     */
    public static void close(Statement statement, Connection connection) {
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    /**
     * 释放资源的方法
     * @param resultSet 释放查询数据结果集对象
     * @param statement 释放执行sql语句的对象
     * @param connection 释放连接数据库的对象
     */
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        close(statement,connection);
    }
}

2.6登录案例的实现

通过键盘录入用户名和密码
判断用户是否登录成功

public class JDBCDemo1 {
    public static void main(String[] args) {
        //1.实现键盘录入数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String userName = scanner.nextLine();
        System.out.println("请输入密码:");
        String password = scanner.nextLine();

        //2.得到用户之后去数据库中查找数据
        if (checkInfo(userName,password)) {
            System.out.println("登录成功...");
        } else {
            System.out.println("登录失败====");
        }
        scanner.close();
    }

    public static boolean checkInfo(String userName, String password){
        //1.需要判断用户名和密码 是否是空
        if (userName == null || password == null) {
            return  false;
        }
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        boolean flag = false;
        try {
            connection = JDBCUtils.getConnection();
            //创建执行语句
            String sql = "SELECT * FROM tab_user WHERE userName = '" + userName + "'" + " AND password = '" + password + "';";
            System.out.println("sql======" + sql);
            statement = connection.createStatement();
            resultSet = statement.executeQuery(sql);

            flag = resultSet.next();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            //释放资源
            JDBCUtils.close(resultSet,statement,connection);
        }

        return flag;
    }
}

*但是以上的代码还存在着问题： SQL注入问题

SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
如何解决这个问题使用PreparedStatement 对象来执行sql语句
修改上述 checkInfo 判断方法

public static boolean checkInfo2(String userName, String password){
        //1.需要判断用户名和密码 是否是空
        if (userName == null || password == null) {
            return  false;
        }
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        boolean flag = false;
        try {
            connection = JDBCUtils.getConnection();
            修改如下
            //创建执行语句
            String sql = "SELECT * FROM tab_user WHERE userName = ?  AND password = ?;";
            System.out.println("sql======" + sql);
            //预编译sql语句
            statement = connection.prepareStatement(sql);
            //给SQL语句中的？ 赋值
            statement.setString(1,userName);
            statement.setString(2,password);
            resultSet = statement.executeQuery();

            flag = resultSet.next();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            //释放资源
            JDBCUtils.close(resultSet,statement,connection);
        }

        return flag;
    }

3.使用JDBC管理事务

3.1 概述

事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
操作：
1. 开启事务
2. 提交事务
3. 回滚事务
. 使用Connection对象来管理事务
1. 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务，默认是关闭的- >在执行sql之前开启事务
2. 提交事务：commit() ：当所有sql都执行完提交事务
3. 回滚事务：rollback() : 在catch中回滚事务

3.2 事务的实现

示例代码：（JDBC中的事务使用）

public class JDBCDemo {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        PreparedStatement preparedStatement1 = null;
        try {
            connection = JDBCUtils.getConnection();
            //开启事务
            connection.setAutoCommit(false);
            String sql = "UPDATE stu SET salary = salary - ? WHERE id = ?;";
            String sql1 = "UPDATE stu SET salary = salary + ? WHERE id = ?;";

            preparedStatement = connection.prepareStatement(sql);
            preparedStatement1 = connection.prepareStatement(sql1);

            //设置值
            preparedStatement.setDouble(1,10);
            preparedStatement.setInt(2,1);

            preparedStatement1.setDouble(1,10);
            preparedStatement1.setInt(2,2);

            preparedStatement.executeUpdate();

            //认为的制造异常 测试事务
            int count = 3/0;
            preparedStatement1.executeUpdate();

            //如果执行都没有异常 则 提交事务
            connection.commit();
        } catch (Exception throwables) {
            //当发生异常时  回滚事务  只要发生异常 就回滚事务
            if (connection != null) {
                try {
                    connection.rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            throwables.printStackTrace();
        } finally {
            JDBCUtils.close(preparedStatement,connection);
            JDBCUtils.close(preparedStatement1,null);
        }
    }
}

4 数据库的连接池

4.1 概述

概念：其实就是一个容器(集合)，存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
好处：
1. 节约资源
2. 用户访问高效
实现：
- 标准接口： DataSource javax.sql包下的
  1. 获取链接：Connection getConnection()：尝试建立与此 DataSource对象所代表的数据源的连接。
  2. 归还链接:Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接
  3. 一般我们不去实现它，由数据库厂商来实现
    - C3P0:数据连接池技术
    - Druid：数据库链接池技术，由阿里巴巴实现

4.2 C3P0: 数据库连接池技术

4.2.1 实现步骤和示例

使用步骤
1. 首先导入c3p0-0.9.5.2.jar包 mchange-commons-java-0.2.12.jar包（注意不要忘记导入数据库的驱动jar包）
2. 定义配置文件：
  - 名称： c3p0.properties 或者 c3p0-config.xml （名称必须是这个两个中的一个）
  - 路径： 直接将文件放在src目录下即可会自动去加载配置文件
3. 创建核心对象数据库的链接池对象ComboPooledDataSource
4. 获取链接： getConnection
示例代码：

public static void readInfo() {
        //使用数据库链接池 C3P0三方库 来链接数据库
        //1.创建核心对象
        DataSource dataSource = new ComboPooledDataSource();
        //2获取链接对象
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = dataSource.getConnection();
            //2.定义sql语句 获取执行sql的对象
            String sql = "select * from stu";
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int salary = resultSet.getInt("salary");
                System.out.println(id + "--" + name + "===" + salary);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            //connection 这里调用close方法不是释放资源，而是回到数据库链接池中，以便下次调用
            JDBCUtils.close(resultSet,preparedStatement,connection);
        }
    }

4.2.2 关于配置文件描述

<c3p0-config>
  <!-- 使用默认的配置读取连接池对象 -->
  <default-config>
  	<!--  连接参数 -->
    <!-- 注册驱动   -->
    <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
<!--    链接mysql的地址-->
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db2</property>
<!--    数据库用户名-->
    <property name="user">root</property>
<!--    数据库密码-->
    <property name="password">guoweiyong</property>
    
    <!-- 连接池参数 -->
<!--    初始化时 有5个数据库链接对象-->
    <property name="initialPoolSize">5</property>
<!--    数据库链接池中最多只有10个链接对象-->
    <property name="maxPoolSize">10</property>
<!--    连接数据的超时时间-->
    <property name="checkoutTimeout">3000</property>
  </default-config>

<!--  我们一般情况下是链接默认配置下的数据库，我们可以单独配置我们需要链接数据的信息，只需要创建了解此对象时，参数传递我们配置的名称
  例子： otherc3p0
  方法： public ComboPooledDataSource(String configName)  既可以链接不同的数据
  
 -->
  <named-config name="otherc3p0"> 
    <!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <!-- 连接池参数 -->
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">8</property>
    <property name="checkoutTimeout">1000</property>
  </named-config>
</c3p0-config>

4.3 Druid数据库链接池

4.3.1 Druid的使用步骤和示例代码

使用步骤：
1. 导入druid-1.0.9.jar包（Druid的jar包）
2. 定义配置文件
  - 是properties形式的
  - 可以是任意名称，可以放在任意目录下（意味着不会自动加载，需要我们手动去加载）
3. 加载配置文件 Properties
4. 获取数据库链接池对象：通过工厂来获取 DruidDataSourceFactory
5. 获取链接
示例代码：

public static void queryInfo()  {
        Properties properties = new Properties();
        InputStream inputStream = JDBCDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            properties.load(inputStream);
            //获取数据库的链接对象
            DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
            connection = dataSource.getConnection();

            String sql = "select * from stu";
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int salary = resultSet.getInt("salary");
                System.out.println(id + "--" + name + "===" + salary);
            }
        }catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //connection 这里调用close方法不是释放资源，而是回到数据库链接池中，以便下次调用
            JDBCUtils.close(resultSet,preparedStatement,connection);
        }

    }

4.3.2 Druid的配置文件基本配置

# 注册驱动
driverClassName=com.mysql.cj.jdbc.Driver
# 数据库的链接地址
url=jdbc:mysql://127.0.0.1:3306/db2
# 数据库的用户名
username=root
# 数据库的密码
password=guoweiyong
# 初始化时候数据库链接对象个数
initialSize=5
# 最多 对象个数
maxActive=10
# 超时时间
maxWait=3000

4.4 JDBC(使用Druid)工具类封装

代码示例：

package com.gy.jdbcPool.demo3.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class JDBCUtils {
    private static DataSource dataSource;

    /*
        加载资源
     */
    static {
        try {
            Properties properties = new Properties();
            properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));

            //创建库链接池对象
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 返回链接对象
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    /**
     * 返回 数据库里连接池对象
     * @return
     */
    public static DataSource getDataSource(){
        return  dataSource;
    }

    /**
     * 释放资源的方法
     * @param statement 释放执行sql语句的对象
     * @param connection 释放连接数据库的对象
     */
    public static void close(Statement statement, Connection connection) {
        close(null,statement,connection);
    }

    /**
     * 释放资源的方法
     * @param resultSet 释放查询数据结果集对象
     * @param statement 释放执行sql语句的对象
     * @param connection 释放连接数据库的对象
     */
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

}

测试代码：

public class JDBCDemo {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            String sql = "select * from stu";
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int salary = resultSet.getInt("salary");
                System.out.println(id + "--" + name + "===" + salary);
            }
        }catch (Exception e) {
            e.printStackTrace();
        } finally {
        	// Connection对象调用close不是释放资源 ，实际上回到数据库连接池中，以便下次调用
            JDBCUtils.close(resultSet,preparedStatement,connection);
        }
    }
}

5.Spring JDBC

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
使用步骤：
1. 导入jar包
2. 创建JdbcTemplate对象。依赖于数据源DataSource：JdbcTemplate template = new JdbcTemplate(ds);
3. 调用JdbcTemplate的方法来完成CRUD的操作
  - update():执行DML语句。增、删、改语句
  - queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
    - 注意：这个方法查询的结果集长度只能是1
  - queryForList():查询结果将结果集封装为list集合
    - 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
  - query():查询结果，将结果封装为JavaBean对象
    - query的参数：RowMapper
      - 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
      - new BeanPropertyRowMapper<类型>(类型.class)
  - queryForObject：查询结果，将结果封装为对象：一般用于聚合函数的查询
示例代码：

package com.gy.jdbcPool.demo4;


import com.gy.jdbcPool.demo3.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;
import java.util.Map;

public class JDBCDemo {
    //获取JdbcTemplate对象
    private JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
    /*
        修改1号数据的 salary 为 10000
     */
    @Test
    public void test1(){
        String sql = "update emp set salary = 10000 where id = ?";
        int update = jdbcTemplate.update(sql, 1001);
        System.out.println("update======" + update);
    }
    /*
        添加一条记录
     */
    @Test
    public void test2(){
        String sql = "insert into emp (id,ename,salary,dept_id) values (?,?,?,?)";
        int count = jdbcTemplate.update(sql, 1015,"张三", 20000, 10);
        System.out.println("count======" + count);
    }

    /*
           删除刚才添加的记录
         */
    @Test
    public void test3(){
        String sql = "delete from emp where id = ?";
        int count = jdbcTemplate.update(sql, 1015);
        System.out.println("count======" + count);
    }

    /*
           查询id为1001的记录，将其封装为Map集合
         */
    @Test
    public void test4(){
        String sql = "select * from emp where id = ?";
        /*
            org.springframework.dao.IncorrectResultSizeDataAccessException: Incorrect result size: expected 1, actual 2
         */
        //String sql = "select * from emp where id = ? or id = ?"; //报错。 只能查询一个结果
        Map<String, Object> stringObjectMap = jdbcTemplate.queryForMap(sql,1001);
        System.out.println("stringObjectMap======" + stringObjectMap);
    }

    /*
           查询所有记录，将其封装为List
         */
    @Test
    public void test5(){
        String sql = "select * from emp";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        for (Map<String, Object> map : maps) {
            System.out.println(map);
        }
    }

    /*
           查询所有记录，将其封装为Emp对象的List集合
         */
    @Test
    public void test6(){
        String sql = "select * from emp";
        //还有一种方式是自己实现RowMapper<T>接口
        List<Empioyee> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Empioyee>(Empioyee.class));
        for (Empioyee empioyee : query) {
            System.out.println(empioyee);
        }
    }

    /*
           查询总记录数
         */
    @Test
    public void test7(){
        String sql = "select count(id) from emp";
        Long aLong = jdbcTemplate.queryForObject(sql, Long.class);
        System.out.println("aLong======" + aLong);
    }
}

GY-93

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习 - JDBC

Java学习 - JDBC1. MAC系统IDEA如何使用JDBC链接MySQL2. JDBC中的常用对象2.1 JDBC快速入门代码2.2 JDBC中常用对象2.3 JDBC操作数据库案例练习2.4 ResultSet案例练习2.5 JDBC工具类的抽取1. MAC系统IDEA如何使用JDBC链接MySQL首先创建一个空的项目：打开IDEA->Creat New Project > Empty Project-> 点击next->给项目命名->选择存放的路径->
复制链接

扫一扫