JDBC 笔记

最新推荐文章于 2024-07-20 23:55:03 发布

Cuzblind

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量115

点赞数

分类专栏： JAVA基础和WEB 文章标签： java jdbc 数据库 mysql

本文链接：https://blog.csdn.net/qq_45812180/article/details/116719151

版权

JAVA基础和WEB 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

第一章：JDBC概述

1.1数据的持久化

持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成。
持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、XML数据文件中。

1.2 JAVA中的数据存储技术

在Java中，数据库存取技术可分为如下几类：
- JDBC直接访问数据库
- JDO (Java Data Object )技术
- 第三方O/R工具，如Hibernate, Mybatis 等
JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等只是更好的封装了JDBC。

1.3 JDBC的介绍

概念：JAVA DataBase Connectivity Java 数据库连接，java语言操作数据库
- JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。
如果没有JDBC，那么Java程序访问数据库时是这样的：

在这里插入图片描述

有了JDBC，Java程序访问数据库时是这样的：

在这里插入图片描述

总结如下：

在这里插入图片描述

1.4 JDBC体系结构

JDBC接口（API）包括两个层次：
- 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。
- 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。

1.5 JDBC程序编写步骤

在这里插入图片描述

代码实现：

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/hotel","root","password")
        Class.forName("com.mysql.jdbc.Driver");
        //4.定义sql语句
        Connection conn = DriverManager.getConnection("jdbc:mysql:///hotel","root","qq1344014423yjy");
//        String sql = "update account set balance = 1000 where id = 1";
        String sql = "update account set balance = 2000";
        //5.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        //6.执行sql
        int count = stmt.executeUpdate(sql);
        //7.处理结果
        System.out.println(count);
        //8.释放资源
        stmt.close();
        conn.close();
    }
}

第二章详解各个对象

2.1 DriverManager：驱动管理对象

功能：
- 注册驱动：告诉程序该使用哪一个数据库驱动jar

static void registerDriver(Driver driver)：注册与给定的驱动程序DriverManager
写代码使用：
Class.forName("com.mysql.jdbc.Driver");

	通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块

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

注意：mysql15之后的驱动jar包可以省略注册驱动的步骤

获取数据库连接
- 方法：

static Connection getConnection(String url, String user, String password)

  - 参数：

1. url：指定连接的路径

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

2.用户名和密码

user：用户名
password：密码

2.2 Connection：数据库连接对象

功能：
- 获取执行sql的对象
  - Statement createStatement()
  - PreparedStatement prepareStatement(String sql)
- 管理事务：
  - 开启事务：setAutoCommit(boolean autoCommit)：调用该方法设置参数为false，即开始事务
  - 提交事务：commit()
  - 回滚事务：rollback()

2.3 Statement：执行sql的对象

执行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）语句

例子：

/*
1. account表 添加一条记录
2. account表 修改记录
3. account表 删除一条记录
*/

public class JdbcDemo2 {
    public static void main(String[] args) {
        Statement stmt = null;
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String sql = "insert into account values(3,'王五',3000)";
          //String sql = "update account set balance = 1500 where id = 3";
          //String sql = "delete from account where id = 3";
            conn = DriverManager.getConnection("jdbc:mysql:///hotel", "root", "qq1344014423yjy");
            stmt = conn.createStatement();
            int count = stmt.executeUpdate(sql);
            System.out.println(count);
            if(count > 0){
                System.out.println("添加成功！");
            }else{
                System.out.println("添加失败！");
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //避免空指针异常
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

2.4 ResultSet：结果集对象，封装查询结果

boolean next()：游标向下移动一行，判断当前行是否是最后一行末尾（是否有数据），如果是，则返回false，如果不是则返回true
getXXX(参数)：获取数据
- XXX：代表数据类型如：int getInt()，String getString()
- 参数：
  - int：代表列的编号，从1开始如：getString(1)
  - String：代表列名称。如：getDouble("balance")
注意：
- 使用步骤：
  - 游标向下移动一行
  - 判断是否有数据
  - 获取数据

例子：

public class JdbcDemo7 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.getConnection("jdbc:mysql:///hotel","root","qq1344014423yjy");
            //3.定义sql
            String sql = "select * from  account";
            //4.获取执行sql对象
            stmt = conn.createStatement();
            //5.执行sql
            rs = stmt.executeQuery(sql);
            //6.处理结果
            //6.1 让游标向下移动一行
            while(rs.next()){
                //6.2 获取数据
                int id = rs.getInt(1);
                String name = rs.getString("name");
                double balance = rs.getDouble(3);
                System.out.println(id + "----" + name + "----" + balance);
            }

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

练习：

/*
定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
				1. 定义Emp类
				2. 定义方法 public List<Emp> findAll(){}
				3. 实现方法 select * from emp;
*/
public class JdbcDemo8 {

    public static void main(String[] args) {
        List<Emp> list = new JdbcDemo8().findAll2();
        System.out.println(list);
        System.out.println(list.size());
    }

    public List<Emp> findAll(){
        Statement stmt = null;
        Connection conn = null;
        ResultSet rs = null;
        List<Emp> list = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql:///hotel", "root", "qq1344014423yjy");
            String sql = "select * from emp";
            stmt = conn.createStatement();
            rs = stmt.executeQuery(sql);
            Emp emp = null;
            list = new ArrayList<Emp>();
            while(rs.next()){
                //获取数据
                int id = rs.getInt("id");
                String ename = rs.getString("ename");
                int job_id = rs.getInt("job_id");
                int mgr = rs.getInt("mgr");
                Date joindate = rs.getDate("joindate");
                double salary = rs.getDouble("salary");
                double bonus = rs.getDouble("bonus");
                int dept_id = rs.getInt("dept_id");
                //创建emp对象
                emp = new Emp();
                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setMgr(mgr);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);

                list.add(emp);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            if(rs != null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
        return list;
    }
}

emp表：

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

    public int getId() {
        return id;
    }

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

    public String getEname() {
        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 double getSalary() {
        return salary;
    }

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

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double 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 "Emp{" +
                "id=" + id +
                ", ename='" + ename + '\'' +
                ", job_id=" + job_id +
                ", mgr=" + mgr +
                ", joindate=" + joindate +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", dept_id=" + dept_id +
                '}';
    }
}

2.5 执行sql的对象

SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
- 输入用户随便，输入密码：a’ or ‘a’ = ‘a’
- sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'
解决SQL注入问题：使用PreparedStatement对象来解决
预编译的SQL：参数使用?作为占位符
步骤：

在这里插入图片描述

给?赋值：setXXX(参数1,参数2)
- 参数1：?的位置编号从1开始
- 参数2：?的值

**注意：**后期都会使用PrepareStatement来完成增删改查的所有操作
可以防止sql注入且效率更高

第三章抽取JDBC工具类

目的：简化书写
分析：
- 注册驱动也抽取
- 抽取一个方法获取连接对象
  - 需求：不想传递参数，还得爆炸工具类的通用性
  - 解决：配置文件
  - 抽取一个方法释放资源

代码实现：

public class JdbcUtil {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
/*
* 文件的读取，只需要读取一次即可拿到这些值。使用静态代码块
* */
    static {
        //获取资源文件，获取值
        try {
            //1.创建Properties集合类
            Properties pro = new Properties();

            //获取src路径下的文件的方式--->ClassLoader类加载器
            ClassLoader classLoader = JdbcUtil.class.getClassLoader();
            URL res = classLoader.getResource("jdbc.properties");
            String path = res.getPath();
//            System.out.println(path);

            //2.加载文件
//            pro.load(new FileReader("src/jdbc.properties"));
            pro.load(new FileReader(path));

            //3.获取数据
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");

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

    }
/*
* 获取连接
* @return 连接对象
* */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,user,password);
    }
/*
* 释放资源
* @param stmt
* @param conn
* */
    public static void close(Statement stmt,Connection conn){
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

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

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

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

练习：

/*
练习：
	* 需求：
		1. 通过键盘录入用户名和密码
		2. 判断用户是否登录成功
			* select * from user where username = "" and password = "";
			* 如果这个sql有查询结果，则成功，反之，则失败
*/
public class JdbcDemo9 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();

        boolean flag = new JdbcDemo9().login2(username,password);
        if(flag){
            System.out.println("登陆成功！");
        }else {
            System.out.println("用户名或密码错误");
        }
    }


    public boolean login(String username,String password){
        if(username == null || password == null){
            return false;
        }
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtil.getConnection();
            String sql = "select * from user where username = '"+username+"' and password = '"+password+"'";
            stmt = conn.createStatement();
            rs = stmt.executeQuery(sql);
            return rs.next();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtil.close(rs,stmt,conn);
        }

        return false;
    }

    //使用preparedStatement
    public boolean login2(String username,String password){
        if(username == null || password == null){
            return false;
        }
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        PreparedStatement pstmt = null;

        try {
            conn = JdbcUtil.getConnection();
            String sql = "select * from user where username = ? and password = ?";
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1,username);
            pstmt.setString(2,password);
            rs = pstmt.executeQuery();
            return rs.next();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtil.close(rs,pstmt,conn);
        }

        return false;
    }
}

关于JDBC-java中mysql语句中的拼接规则参考本人博客文章拼接规则

第四章 JDBC控制事务

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

代码：

public class JdbcDemo10 {

    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pstmt1 = null;
        PreparedStatement pstmt2 = null;

        try {
            //1.获取连接
            conn = JdbcUtil.getConnection();
            //开始事务
            conn.setAutoCommit(false);
            //2.定义sql
            //2.1 张三 - 500
            String sql1 = "update account set balance = balance - ? where id = ?";
            //2.2 李四 + 500
            String sql2 = "update account set balance = balance + ? where id = ?";
            //3.获取执行sql对象
            pstmt1 = conn.prepareStatement(sql1);
            pstmt2 = conn.prepareStatement(sql2);
            //4.设置参数
            pstmt1.setDouble(1,500);
            pstmt1.setInt(2,1);

            pstmt2.setDouble(1,500);
            pstmt2.setInt(2,2);
            //5.执行sql
            pstmt1.executeUpdate();
            //手动制造异常
            int i = 3 / 0;
            pstmt2.executeUpdate();
            //提交事务
            conn.commit();
        } catch (SQLException throwables) {
            try {
                if(conn != null){
                    //事务回滚
                    conn.rollback();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            throwables.printStackTrace();
        }finally {
            JdbcUtil.close(pstmt1,conn);
            JdbcUtil.close(pstmt2,null);
        }
    }
}

第五章数据库连接池

5.1 JDBC数据库连接池的必要性

在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：
- 在主程序（如servlet、beans）中建立数据库连接
- 进行sql操作
- 断开数据库连接
这种模式开发，存在的问题:
- 普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection 加载到内存中，再验证用户名和密码(得花费0.05s～1s的时间)。需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。**数据库的连接资源并没有得到很好的重复利用。**若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
- **对于每一次数据库连接，使用完后都得断开。**否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。（回忆：何为Java的内存泄漏？）
- 这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。

5.2 数据库连接池技术

为解决传统开发中的数据库连接问题，可以采用数据库连接池技术。
数据库连接池的基本思想：就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。
数据库连接池技术的优点
1. 资源重用
由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
2. 更快的系统反应速度
数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间
3. 新的资源分配手段
对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源
4. 统一的连接管理，避免数据库连接泄漏
在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露

5.3 多种开源的数据库连接池

JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：
- DBCP 是Apache提供的数据库连接池。tomcat 服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持。
- C3P0 是一个开源组织提供的一个数据库连接池，**速度相对较慢，稳定性还可以。**hibernate官方推荐使用
- Proxool 是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点
- BoneCP 是一个开源组织提供的数据库连接池，速度快
- Druid 是阿里提供的数据库连接池，据说是集DBCP 、C3P0 、Proxool 优点于一身的数据库连接池，但是速度不确定是否有BoneCP快
DataSource 通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接池
DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速度。
特别注意：
- 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
- 当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

5.3.1 C3P0 数据库连接池技术

步骤：

在这里插入图片描述

代码：

public class C3p0Demo1 {

    public static void main(String[] args) throws SQLException {
        DataSource ds = new ComboPooledDataSource();
        Connection conn = ds.getConnection();
        System.out.println(conn);
    }
}

5.3.2 Druid 数据库连接池（阿里巴巴提供）

步骤：
在这里插入图片描述

代码：

public class DruidDemo {

    public static void main(String[] args) throws Exception {

        //加载配置文件
        Properties pro = new Properties();
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);

        //获取数据库连接池
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);

        //获取连接
        Connection conn = ds.getConnection();
        System.out.println(conn);
    }
}

Utils工具包：

/*
1. 定义一个类 JDBCUtils
		2. 提供静态代码块加载配置文件，初始化连接池对象
		3. 提供方法
			1. 获取连接方法：通过数据库连接池获取连接
			2. 释放资源
			3. 获取连接池的方法
*/
public class JdbcUtils {
    private static DataSource ds;

    static {

        try {
            Properties pro = new Properties();
            pro.load(JdbcUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    public static void close(Statement stmt,Connection conn){
        close(null,stmt,conn);
    }

    public static void close(ResultSet rs,Statement stmt, Connection conn){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    public static DataSource getDataSource(){
        return ds;
    }
}

第六章 Spring JDBC

6.1 基本步骤

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤：
在这里插入图片描述

update():执行DML语句。增、删、改语句
queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value将这条记录封装为一个map集合
- 注意：这个方法查询的结果集长度只能是1
queryForList():查询结果将结果集封装为list集合
- 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
query():查询结果，将结果封装为JavaBean对象
- query的参数：RowMapper
  一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
  new BeanPropertyRowMapper<类型>(类型.class)
queryForObject：查询结果，将结果封装为对象
- 一般用于聚合函数的查询

6.2 基本操作代码

练习：

public class JdbcTemplateDemo2 {

    //Junit单元测试，可以让方法独立执行

    //1. 获取JDBCTemplate对象
    JdbcTemplate template = new JdbcTemplate(JdbcUtils.getDataSource());
    /*
     * 1. 修改1001号数据的 salary 为 10000
     */
    @Test
    public void test1(){

        String sql = "update emp set salary = 10000 where id = 1001";

        int count = template.update(sql);
        System.out.println(count);
    }

    /*
     * 2. 添加一条记录
     */
    @Test
    public void test2(){
        String sql = "insert into emp(id,ename,dept_id) values (?,?,?)";
        int count = template.update(sql, 1006, "郭靖", 10);
        System.out.println(count);
    }

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

    //查询结果将结果封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
    @Test
    public void test4(){
        String sql = "select * from emp where id = ? or ?";
        Map<String,Object> map = template.queryForMap(sql,1001);
        System.out.println(map);
    }

    //将每一条记录封装为一个map集合，再将map集合装载到list集合中
    @Test
    public void test5(){
        String sql = "select * from emp";
        List<Map<String, Object>> list = template.queryForList(sql);

        for (Map<String, Object> stringObjectMap : list) {
            System.out.println(stringObjectMap);
        }
    }

    /*
     * 6. 查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void test6(){
        String sql = "select * from emp";
        List<Emp> list = template.query(sql, new RowMapper<Emp>() {
            @Override
            public Emp mapRow(ResultSet rs, int i) throws SQLException {
                Emp emp = new Emp();
                int id = rs.getInt("id");
                String ename = rs.getString("ename");
                int job_id = rs.getInt("job_id");
                int mgr = rs.getInt("mgr");
                Date joindate = rs.getDate("joindate");
                double salary = rs.getDouble("salary");
                double bonus = rs.getDouble("bonus");
                int dept_id = rs.getInt("dept_id");

                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setMgr(mgr);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);

                return emp;
            }
        });

        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /*
     * 6. 查询所有记录，将其封装为Emp对象的List集合(test6的优化版本)
     */

    @Test
    public void test7(){
        String sql = "select * from emp";
        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

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

6.3 JdbcTemplate中RowMapper的粗浅理解

RowMapper映射Bean容器的用法

这大概是使用最频繁的用法，非常实用的方法

public class MyRowMapper implements RowMapper<User> {
    @Override
    public User mapRow(ResultSet rs, int i) throws SQLException {

        int id = rs.getInt("id");
        String username1 = rs.getString("username");
        String password1 = rs.getString("password");
        String email = rs.getString("email");
        int power = rs.getInt("power");
        int status = rs.getInt("status");

        User user = new User();

        user.setId(id);
        user.setUsername(username1);
        user.setPassword(password1);
        user.setEmail(email);
        user.setPower(power);
        user.setStatus(status);

        return user;
    }
}

如此，完成了一个对User类的RowMapper映射。可以通过该类返回单个对象

**
     * 功能：查询返回单个对象
     * 步骤：新建MyRowMapper类实现RowMapper接口，重写mapRow方法，指定返回User对象
     */
    public static void queryForObject(JdbcTemplate jdbcTemplate) {
        String sql = "select * from user where username = ?";
//        新建MyRowMapper类实现RowMapper接口，重写mapRow方法，指定返回User对象
        User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "Tom");
        System.out.println(user);
    }

本人语雀博客，其他内容持续更新，本人小白，轻喷

Cuzblind

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JDBC 笔记

第一章：JDBC概述1.1数据的持久化持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成。持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、XML数据文件中。1.2 JAVA中的数据存储技术在Java中，数据库存取技术可分为如下几类：JDBC直接访问数据库JDO (Java Data Obj.
复制链接

扫一扫