Java学习 - JDBC

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

  1. 首先创建一个空的项目:打开IDEA->Creat New Project > Empty Project-> 点击next->给项目命名->选择存放的路径-> 点击finish完成在这里插入图片描述

  2. 然后下载JDBC驱动

    • 官网下载:JDBC下载
    • Select Operating Independent 选择 Platform Independent即可。
    • 跳转到下载界面界面,如果不想登录直接点击这行小字在这里插入图片描述
  3. 点击 File->Project Structure-SDKs

    • 在这里插入图片描述
    • 点击 左下角的 + 号 把mysql-connector-java-8.0.21.jar包导入
  4. 导入之后看左边的External Libaries中 有没有mysql-connector-java-8.0.21.jar在这里插入图片描述

  5. 测试下代码 ,如果一下代码测试成功,就代表导入驱动成功

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

2. JDBC中的常用对象

概念:Java DataBase Connectivity Java 数据库连接, Java语言操作数据库

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

2. 1JDBC快速入门代码

  1. 导入mysql-connector-java-8.0.21.jar包到项目
  2. 注册驱动
  3. 获取数据库连接对象 Connection
  4. 定义sql
  5. 获取执行sql语句的对象 Statement
  6. 执行sql,接受返回结果
  7. 处理结果
  8. 释放资源
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登录案例的实现

  1. 通过键盘录入用户名和密码
  2. 判断用户是否登录成功
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);
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值