一、概念

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

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

二、快速入门

2.1 步骤

  1. 1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
  2.     - 复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
  3.     - 右键-->Add As Library
  4. 2. 注册驱动
  5. 3. 获取数据库连接对象 Connection
  6. 4. 定义sql
  7. 5. 获取执行sql语句的对象 Statement
  8. 6. 执行sql，接受返回结果
  9. 7. 处理结果
  10. 8. 释放资源

2.2 代码实现

  1. //1. 导入驱动jar包
  2. //2.注册驱动
  3. Class.forName("com.mysql.jdbc.Driver");
  4. //3.获取数据库连接对象
  5. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
  6. //4.定义sql语句
  7. String sql = "update account set balance = 500 where id = 1";
  8. //5.获取执行sql的对象 Statement
  9. Statement stmt = conn.createStatement();
  10. //6.执行sql
  11. int count = stmt.executeUpdate(sql);
  12. //7.处理结果
  13. System.out.println(count);
  14. //8.释放资源
  15. stmt.close();
  16. conn.close();

三、各对象详解

3.1 DriverManager

驱动管理对象

① 注册驱动：告诉程序该使用哪一个数据库驱动jar。

  • DriverManager类的注册驱动方法
  1. static void registerDriver(Driver driver) ：注册给定的驱动程序 DriverManager 。
  • 注册驱动代码
  1. Class.forName("com.mysql.jdbc.Driver");
  • 通过查看源码发现：在 com.mysql.jdbc.Driver 类中存在静态代码块
  1. static {
  2.     try {
  3.         java.sql.DriverManager.registerDriver(new Driver());
  4.     } catch (SQLException E) {
  5.         throw new RuntimeException("Can't register driver!");
  6.     }
  7. }

综上： 当使用 Class.forName() 将 com.mysql.jdbc.Driver 类导入内存时，会首先自动调用静态代码块，静态代码块中的 java.sql.DriverManager.registerDriver(new Driver()) 语句注册了一个驱动。

注意： mysql5之后的驱动jar包可以省略注册驱动的步骤。因为在 mysql-connector-java-5.1.37-bin.jar!\META-INF\services\java.sql.Driver 这个文件中配置了 com.mysql.jdbc.Driver 类，如果没写注册驱动的代码，程序会自动帮助注册。

② 获取数据库连接

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

  • url：指定连接的路径

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

3.2 Connection

数据库连接对象

① 获取执行sql 的对象

  1. Statement createStatement()
  2. PreparedStatement prepareStatement(String sql)

② 管理事务

  1. - 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
  2. - 提交事务：commit() 
  3. - 回滚事务：rollback()

3.3 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)语句
  1. Statement stmt = null;
  2. Connection conn = null;
  3. try {
  4.     //1. 注册驱动
  5.     Class.forName("com.mysql.jdbc.Driver");
  6.     //2. 定义sql
  7.     String sql = "insert into account values(null,'王五',3000)";
  8.     //3.获取Connection对象
  9.     conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  10.     //4.获取执行sql的对象 Statement
  11.     stmt = conn.createStatement();
  12.     //5.执行sql
  13.     int count = stmt.executeUpdate(sql);//影响的行数
  14.     //6.处理结果
  15.     System.out.println(count);
  16.     if(count > 0){
  17.         System.out.println("添加成功！");
  18.     }else{
  19.         System.out.println("添加失败！");
  20.     }
  22. } catch (ClassNotFoundException e) {
  23.     e.printStackTrace();
  24. } catch (SQLException e) {
  25.     e.printStackTrace();
  26. }finally {
  27.     //stmt.close();
  28.     //7. 释放资源
  29.     //避免空指针异常
  30.     if(stmt != null){
  31.         try {
  32.             stmt.close();
  33.         } catch (SQLException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  38.     if(conn != null){
  39.         try {
  40.             conn.close();
  41.         } catch (SQLException e) {
  42.             e.printStackTrace();
  43.         }
  44.     }
  45. }

3.4 ResultSet

3.4.1 方法

结果集对象，封装查询结果。

  • boolean next()：游标向下移动一行，判断当前行是否是最后一行的下面一行，如果是，则返回false，如果不是则返回true
  • getXxx(参数)：获取数据（Xxx：代表数据类型，如： int getInt() , String getString()）
  • 参数：
  1. int：代表列的编号，从1开始。如： getString(1)
  2. String：代表列名称。 如： getDouble(“balance”)

3.4.2 使用步骤

  1. //循环判断游标是否是最后一行末尾。
  2. while(rs.next()){
  3.     //获取数据
  4.     int id = rs.getInt(1);
  5.     String name = rs.getString("name");
  6.     double balance = rs.getDouble(3);
  7.     System.out.println(id + "---" + name + "---" + balance);
  8.  }

3.4.3 练习

① 抽取工具类
  • 抽取 注册驱动
  • 抽取一个方法 获取连接对象
  • 抽取一个方法 释放资源
  1. //JDBCUtils.java
  2. public class JDBCUtils {
  3.     private static String url;
  4.     private static String user;
  5.     private static String password;
  6.     private static String driver;
  7.     static {
  8.         try {
  9.             Properties properties = new Properties();
  10.             ClassLoader classLoader = JDBCUtils.class.getClassLoader();
  11.             URL resource = classLoader.getResource("jdbc.properties");
  12.             String path = resource.getPath();
  13.             properties.load(new FileReader(path));
  14.             url = properties.getProperty("url");
  15.             user = properties.getProperty("user");
  16.             password = properties.getProperty("password");
  17.             driver = properties.getProperty("driver");
  18.             Class.forName(driver);
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         } catch (ClassNotFoundException e) {
  22.             e.printStackTrace();
  23.         }
  24.     }
  26.     public static Connection getConnection() throws SQLException {
  27.         return DriverManager.getConnection(url,user,password);
  28.     }
  31.     public static void close(Statement statement,Connection connection){
  32.         if (statement != null){
  33.             try {
  34.                 statement.close();
  35.             } catch (SQLException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         }
  40.         if (connection != null){
  41.             try {
  42.                 connection.close();
  43.             } catch (SQLException e) {
  44.                 e.printStackTrace();
  45.             }
  46.         }
  47.     }
  50.     public static void close(ResultSet resultSet, Statement statement, Connection connection){
  51.         if (resultSet != null){
  52.             try {
  53.                 resultSet.close();
  54.             } catch (SQLException e) {
  55.                 e.printStackTrace();
  56.             }
  57.         }
  59.         if (statement != null){
  60.             try {
  61.                 statement.close();
  62.             } catch (SQLException e) {
  63.                 e.printStackTrace();
  64.             }
  65.         }
  67.         if (connection != null){
  68.             try {
  69.                 connection.close();
  70.             } catch (SQLException e) {
  71.                 e.printStackTrace();
  72.             }
  73.         }
  74.     }
  75. }
  1. //jdbc.properties（放在src目录下）
  2. url = jdbc:mysql://localhost:3306/db4
  3. user = root
  4. password = root
  5. driver = com.mysql.jdbc.Driver

② 使用工具类
  1. 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
  2. 1. 定义Emp类
  3. 2. 定义方法 public List<Emp> findAll(){}
  4. 3. 实现方法 select * from emp;
  1. public class Demo06 {
  2.    public static void main(String[] args) {
  3.        System.out.println(findAll());
  4.    }
  5.    public static List<Emp> findAll(){
  6.        Connection connection = null;
  7.        Statement statement = null;
  8.        ResultSet resultSet = null;
  9.        List<Emp> list = null;
  10.        try {
  11.            connection = JDBCUtils.getConnection();
  12.            statement = connection.createStatement();
  13.            String sql = "select * from emp";
  14.            resultSet = statement.executeQuery(sql);
  15.            list = new ArrayList<>();
  16.            while(resultSet.next()){
  17.                int id = resultSet.getInt("id");
  18.                String ename = resultSet.getString("ename");
  19.                int job_id = resultSet.getInt("job_id");
  20.                int mgr = resultSet.getInt("mgr");
  21.                Date joindate = resultSet.getDate("joindate");
  22.                double salary = resultSet.getDouble("salary");
  23.                double bonus = resultSet.getDouble("bonus");
  24.                int dept_id = resultSet.getInt("dept_id");
  26.                Emp emp = new Emp();
  27.                emp.setId(id);
  28.                emp.setEname(ename);
  29.                emp.setJob_id(job_id);
  30.                emp.setMgr(mgr);
  31.                emp.setJoindate(joindate);
  32.                emp.setSalary(salary);
  33.                emp.setBonus(bonus);
  34.                emp.setDept_id(dept_id);
  36.                list.add(emp);
  37.            }
  38.        } catch (SQLException e) {
  39.            e.printStackTrace();
  40.        }finally {
  41.            JDBCUtils.close(resultSet,statement,connection);
  42.        }
  43.        return list;
  44.    }
  45. }

③ 登录案例
  1. public class Demo07 {
  2.     public static void main(String[] args) {
  3.         Scanner scanner = new Scanner(System.in);
  4.         System.out.println("请输入用户名");
  5.         String username = scanner.nextLine();
  6.         System.out.println("请输入密码");
  7.         String password = scanner.nextLine();
  8.         if(login(username,password)){
  9.             System.out.println("登录成功");
  10.         } else {
  11.             System.out.println("登录失败");
  12.         }
  13.     }
  15.     public static boolean login(String username, String password){
  16.         Connection connection = null;
  17.         Statement statement = null;
  18.         ResultSet resultSet = null;
  19.         if(username == null || password == null){
  20.             return false;
  21.         }
  22.         try {
  23.             connection = JDBCUtils.getConnection();
  24.             String sql = "select * from user where username = '" + username + "'" + "and password = '" + password + "';";
  25.             statement = connection.createStatement();
  26.             resultSet = statement.executeQuery(sql);
  27.             return resultSet.next();
  28.         } catch (SQLException e) {
  29.             e.printStackTrace();
  30.         } finally {
  31.             JDBCUtils.close(resultSet,statement,connection);
  32.         }
  33.         return false;
  34.     }
  35. }

3.5 PreparedStatement

执行sql的对象

3.5.1 SQL注入问题

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

3.5.2 使用步骤

① 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar

② 注册驱动

③ 获取数据库连接对象 Connection

④ 定义sql

  • 注意：sql的参数使用 ? 作为占位符。 如：select * from user where username = ? and password = ?;

⑤ 获取执行sql语句的PreparedStatement对象，使用Connection类中的 prepareStatement(String sql) 方法

⑥ 给 ? 赋值

  • 方法： setXxx(参数1,参数2)

    • 参数1：？的位置编号 从1 开始
    • 参数2：？的值

⑦ 执行sql，接受返回结果，不需要传递sql语句

⑧ 处理结果

⑨ 释放资源

注意： 后期都会使用PreparedStatement来完成增删改查的所有操作

  • 可以防止SQL注入
  • 效率更高

3.6 事务管理

3.6.1 事务

一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。

有以下三种操作：① 开启事务 ② 提交事务 ③ 回滚事务

3.6.2 管理事务

使用Connection对象管理事务

① 开启事务 ：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务。（在执行sql之前开启事务）

② 提交事务 ：commit() （当所有sql都执行完提交事务）

③ 回滚事务 ：rollback() （在catch中回滚事务）

  1. public class JDBCDemo10 {
  2.     public static void main(String[] args) {
  3.         Connection conn = null;
  4.         PreparedStatement pstmt1 = null;
  5.         PreparedStatement pstmt2 = null;
  7.         try {
  8.             //1.获取连接
  9.             conn = JDBCUtils.getConnection();
  10.             //开启事务
  11.             conn.setAutoCommit(false);
  13.             //2.定义sql
  14.             //2.1 张三 - 500
  15.             String sql1 = "update account set balance = balance - ? where id = ?";
  16.             //2.2 李四 + 500
  17.             String sql2 = "update account set balance = balance + ? where id = ?";
  18.             //3.获取执行sql对象
  19.             pstmt1 = conn.prepareStatement(sql1);
  20.             pstmt2 = conn.prepareStatement(sql2);
  21.             //4. 设置参数
  22.             pstmt1.setDouble(1,500);
  23.             pstmt1.setInt(2,1);
  25.             pstmt2.setDouble(1,500);
  26.             pstmt2.setInt(2,2);
  27.             //5.执行sql
  28.             pstmt1.executeUpdate();
  29.             // 手动制造异常
  30.             int i = 3/0;
  32.             pstmt2.executeUpdate();
  33.             //提交事务
  34.             conn.commit();
  35.         } catch (Exception e) {//由于开始事务和关闭事务之间可能存在各种错误，所以，此处抓的错误是大的Exception
  36.             //事务回滚
  37.             try {
  38.                 if(conn != null) {
  39.                     conn.rollback();
  40.                 }
  41.             } catch (SQLException e1) {
  42.                 e1.printStackTrace();
  43.             }
  44.             e.printStackTrace();
  45.         }finally {
  46.             JDBCUtils.close(pstmt1,conn);
  47.             JDBCUtils.close(pstmt2,null);
  48.         }
  50.     }
  52. }

四、数据库连接池

4.1 概念

其实就是一个容器(集合)，存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。

好处：① 节约资源 ② 用户访问高效

4.2 实现

  • 标准接口：javax.sql.DataSource

  • 方法：
    ① 获取连接：getConnection()
    ② 归还连接：Connection类的close()。如果连接对象Connection是从连接池中获取的，那么调用Connection的close()方法，则不会再关闭连接了，而是归还连接

  • 一般我们不去实现它，有数据库厂商来实现
    ① C3P0：数据库连接池技术，同hibernate一同发布的，较老。
    ② Druid：数据库连接池实现技术，十分高效，由阿里巴巴提供的。

4.3 C3P0

① 导入jar包 (两个) c3p0-0.9.5.2.jar 和 mchange-commons-java-0.2.12.jar

  • 不要忘记导入数据库驱动jar包

② 定义配置文件

  • 名称： c3p0.properties 或者 c3p0-config.xml
  • 路径：直接将文件放在src目录下即可。

③ 创建核心对象：数据库连接池对象 ComboPooledDataSource

④ 获取连接： getConnection()

  1. //1.创建数据库连接池对象
  2. DataSource ds  = new ComboPooledDataSource();
  3. //2. 获取连接对象
  4. Connection conn = ds.getConnection();
  1. //c3p0-config.xml
  2. <c3p0-config>
  3.   <!-- 使用默认的配置读取连接池对象 -->
  4.   <default-config>
  5.       <!--  连接参数 -->
  6.     <property name="driverClass">com.mysql.jdbc.Driver</property>
  7.     <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property>
  8.     <property name="user">root</property>
  9.     <property name="password">root</property>
  11.     <!-- 连接池参数 -->
  12.     <!-- 初始申请的连接数量 -->
  13.     <property name="initialPoolSize">5</property>
  14.     <!-- 最大的连接数量 -->
  15.     <property name="maxPoolSize">10</property>  
  16.     <!-- 超时时间 -->
  17.     <property name="checkoutTimeout">3000</property>
  18.   </default-config>
  20.   <named-config name="otherc3p0"> 
  21.     <!--  连接参数 -->
  22.     <property name="driverClass">com.mysql.jdbc.Driver</property>
  23.     <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property>
  24.     <property name="user">root</property>
  25.     <property name="password">root</property>
  27.     <!-- 连接池参数 -->
  28.     <property name="initialPoolSize">5</property>
  29.     <property name="maxPoolSize">8</property>
  30.     <property name="checkoutTimeout">1000</property>
  31.   </named-config>
  32. </c3p0-config>
  1. //获取指定配置名称的ComboPooledDataSource
  2. DataSource ds  = new ComboPooledDataSource("otherc3p0");

4.4 druid

4.4.1 使用步骤

① 导入jar包 druid-1.0.9.jar

② 定义配置文件

  • 是properties形式的
  • 可以叫任意名称，可以放在任意目录下

③ 加载配置文件：Properties

④ 获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory

⑤ 获取连接：getConnection()

  1. //加载配置文件
  2. Properties pro = new Properties();
  3. InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
  4. pro.load(is);
  5. //获取连接池对象
  6. DataSource ds = DruidDataSourceFactory.createDataSource(pro);
  7. //获取连接
  8. Connection conn = ds.getConnection();
  1. //druid.properties
  2. driverClassName=com.mysql.jdbc.Driver
  3. url=jdbc:mysql://127.0.0.1:3306/db3
  4. username=root
  5. password=root
  6. initialSize=5
  7. maxActive=10
  8. maxWait=3000

4.4.2 定义工具类

① 定义一个类 JDBCUtils

② 提供静态代码块加载配置文件，初始化连接池对象

③ 提供方法

  • 获取连接方法：通过数据库连接池获取连接
  • 释放资源
  • 获取连接池的方法
  1. public class JDBCUtils {
  3.     //1.定义成员变量 DataSource
  4.     private static DataSource ds ;
  6.     static{
  7.         try {
  8.             //1.加载配置文件
  9.             Properties pro = new Properties();
  10.             pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
  11.             //2.获取DataSource
  12.             ds = DruidDataSourceFactory.createDataSource(pro);
  13.         } catch (IOException e) {
  14.             e.printStackTrace();
  15.         } catch (Exception e) {
  16.             e.printStackTrace();
  17.         }
  18.     }
  20.     //获取连接
  21.     public static Connection getConnection() throws SQLException {
  22.         return ds.getConnection();
  23.     }
  25.     //释放资源
  26.     public static void close(Statement stmt,Connection conn){
  27.        close(null,stmt,conn);
  28.     }
  30.     public static void close(ResultSet rs , Statement stmt, Connection conn){
  31.         if(rs != null){
  32.             try {
  33.                 rs.close();
  34.             } catch (SQLException e) {
  35.                 e.printStackTrace();
  36.             }
  37.         }
  39.         if(stmt != null){
  40.             try {
  41.                 stmt.close();
  42.             } catch (SQLException e) {
  43.                 e.printStackTrace();
  44.             }
  45.         }
  47.         if(conn != null){
  48.             try {
  49.                 conn.close();//归还连接
  50.             } catch (SQLException e) {
  51.                 e.printStackTrace();
  52.             }
  53.         }
  54.     }
  56.     //获取连接池方法
  57.     public static DataSource getDataSource(){
  58.         return  ds;
  59.     }
  61. }

五、jdbc Template

5.1 步骤

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发。

① 导入jar包

② 创建JdbcTemplate对象。依赖于数据源DataSource

  • JdbcTemplate template = new JdbcTemplate(ds);

③ 调用JdbcTemplate的方法来完成CRUD的操作

  • update() ：执行DML语句。增、删、改语句
  • queryForMap() ：查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合（注意：这个方法查询的结果集长度只能是1，否则要用queryForList()）
  • queryForList() ：查询结果将结果集封装为list集合（注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中）

  • query() ：查询结果，将结果封装为JavaBean对象

    • query的参数：RowMapper

      • 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
      • new BeanPropertyRowMapper<类型>(类型.class)
  • queryForObject() ：查询结果，将结果封装为对象（一般用于聚合函数的查询）

5.2 入门

  1. public class JdbcTemplateDemo1 {
  2.     public static void main(String[] args) {
  3.         //1.导入jar包
  4.         //2.创建JDBCTemplate对象
  5.         JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());//这里用的是4.4.2的工具类
  6.         //3.调用方法
  7.         String sql = "update account set balance = 5000 where id = ?";
  8.         int count = template.update(sql, 3);
  9.         System.out.println(count);
  10.     }
  11. }

5.3 练习

  1. 1. 修改1号数据的 salary 为 10000
  2. 2. 添加一条记录
  3. 3. 删除刚才添加的记录
  4. 4. 查询id为1的记录，将其封装为Map集合
  5. 5. 查询所有记录，将其封装为List
  6. 6. 查询所有记录，将其封装为Emp对象的List集合
  7. 7. 查询总记录数
  1. public class JdbcTemplateDemo2 {
  3.     //Junit单元测试，可以让方法独立执行
  6.     //1. 获取JDBCTemplate对象
  7.     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
  8.     /**
  9.      * 1. 修改1号数据的 salary 为 10000
  10.      */
  11.     @Test
  12.     public void test1(){
  14.         //2. 定义sql
  15.         String sql = "update emp set salary = 10000 where id = 1001";
  16.         //3. 执行sql
  17.         int count = template.update(sql);
  18.         System.out.println(count);
  19.     }
  21.     /**
  22.      * 2. 添加一条记录
  23.      */
  24.     @Test
  25.     public void test2(){
  26.         String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
  27.         int count = template.update(sql, 1015, "郭靖", 10);
  28.         System.out.println(count);
  30.     }
  32.     /**
  33.      * 3.删除刚才添加的记录
  34.      */
  35.     @Test
  36.     public void test3(){
  37.         String sql = "delete from emp where id = ?";
  38.         int count = template.update(sql, 1015);
  39.         System.out.println(count);
  40.     }
  42.     /**
  43.      * 4.查询id为1001的记录，将其封装为Map集合
  44.      * 注意：这个方法查询的结果集长度只能是1
  45.      */
  46.     @Test
  47.     public void test4(){
  48.         String sql = "select * from emp where id = ? or id = ?";
  49.         Map<String, Object> map = template.queryForMap(sql, 1001,1002);
  50.         System.out.println(map);
  51.         //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
  53.     }
  55.     /**
  56.      * 5. 查询所有记录，将其封装为List
  57.      */
  58.     @Test
  59.     public void test5(){
  60.         String sql = "select * from emp";
  61.         List<Map<String, Object>> list = template.queryForList(sql);
  63.         for (Map<String, Object> stringObjectMap : list) {
  64.             System.out.println(stringObjectMap);
  65.         }
  66.     }
  68.     /**
  69.      * 6. 查询所有记录，将其封装为Emp对象的List集合
  70.      */
  72.     @Test
  73.     public void test6(){
  74.         String sql = "select * from emp";
  75.         List<Emp> list = template.query(sql, new RowMapper<Emp>() {
  77.             @Override
  78.             public Emp mapRow(ResultSet rs, int i) throws SQLException {
  79.                 Emp emp = new Emp();
  80.                 int id = rs.getInt("id");
  81.                 String ename = rs.getString("ename");
  82.                 int job_id = rs.getInt("job_id");
  83.                 int mgr = rs.getInt("mgr");
  84.                 Date joindate = rs.getDate("joindate");
  85.                 double salary = rs.getDouble("salary");
  86.                 double bonus = rs.getDouble("bonus");
  87.                 int dept_id = rs.getInt("dept_id");
  89.                 emp.setId(id);
  90.                 emp.setEname(ename);
  91.                 emp.setJob_id(job_id);
  92.                 emp.setMgr(mgr);
  93.                 emp.setJoindate(joindate);
  94.                 emp.setSalary(salary);
  95.                 emp.setBonus(bonus);
  96.                 emp.setDept_id(dept_id);
  98.                 return emp;
  99.             }
  100.         });
  103.         for (Emp emp : list) {
  104.             System.out.println(emp);
  105.         }
  106.     }
  108.     /**
  109.      * 6. 查询所有记录，将其封装为Emp对象的List集合
  110.      */
  112.     @Test
  113.     public void test6_2(){
  114.         String sql = "select * from emp";
  115.         List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
  116.         for (Emp emp : list) {
  117.             System.out.println(emp);
  118.         }
  119.     }
  121.     /**
  122.      * 7. 查询总记录数
  123.      */
  125.     @Test
  126.     public void test7(){
  127.         String sql = "select count(id) from emp";
  128.         Long total = template.queryForObject(sql, Long.class);
  129.         System.out.println(total);
  130.     }
  132. }