JDBC入门学习(更新完结)

什么是JDBC？

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

下面以java代码来操作数据库为案例来演示步骤：

/** * 步骤： 1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar 1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下 2.右键-->Add As Library 2. 注册驱动 3. 获取数据库连接对象 Connection 4. 定义sql 5. 获取执行sql语句的对象 Statement 6. 执行sql，接受返回结果 7. 处理结果 8. 释放资源 */
public class TestMySQL {
   
    public static void main(String[] args) throws Exception {
   
        //1. 导入驱动jar包
        //2.注册驱动
        Class cls = Class.forName("com.mysql.jdbc.Driver");
        //3.获取数据库连接对象
        Connection conn = DriverManager.
                getConnection("jdbc:mysql://localhost:3306/db1", "root", "809080");
        //4.定义sql语句
        String sql = "update account set balance = 1000 where id = 1";
        //5.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        6.执行sql，rst影响的行数
        int rst = stmt.executeUpdate(sql);
        //7.处理结果
        System.out.println(rst);
        //8.释放资源
        stmt.close();
        conn.close();
    }
}

详解各个重要对象

DriverManager驱动管理对象
功能:
1. 注册驱动：告诉程序应该使用哪一个数据库驱动jar
  static DriverManager.registerDriver(new Driver()):注册给定的驱动程序DriverManager
  写代码使用：Class.forName(“com.mysql.jdbc.Driver”);即可
  通过查看源代码可见，在com.mysql.jdbc.Driver存在静态块
```
     static {
     
    try {
     
        DriverManager.registerDriver(new Driver());
    } catch (SQLException var1) {
     
        throw new RuntimeException("Can't register driver!");
    }
    }
```
注意：mysql5之后，Class.forName(“com.mysql.jdbc.Driver”);可以省略不写，系统自动驱动
- 获取数据库连接：
  方法：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:密码
Connection：数据库连接对象
功能：
1. 获取执行sql 的对象
  * Statement createStatement()
  * PreparedStatement prepareStatement(String sql)
2. 管理事务：
  * 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
  * 提交事务：commit()
  * 回滚事务：rollback()
Statement：执行sql的对象

执行sql
1. boolean execute(String sql) ：可以执行任意的sql 语句了解
2. int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句
返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功返回值>0的则执行成功，反之，则失败。
3. ResultSet executeQuery(String sql) ：执行DQL（select)语句
4. 练习：

1、 account表 添加一条记录
	insert into account value(null,'liuzeyu',3000)
2、 account表 修改记录
	update account set balance = 100000 where id = 3
3、account表 删除一条记录
	delete FROM  account where id  = 3
//替换上述对应的sql执行相应的DML操作
public class JDBCDemo1 {
    public static void main(String[] args) {

        Connection conn = null;
        Statement statement = null;
        //0.导入jar包

        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.定义sql
            String sql = "insert into account value(null,'liuzeyu',3000);";
            //4.获取数据库连接对象
                conn = DriverManager.
                        getConnection("jdbc:mysql:///db1","root","809080");

            //5.获取执行sql
            statement = conn.createStatement();
            //6.执行sql,返回影响行数结果
            int rst = statement.executeUpdate(sql);
            //7.处理结果
            if(rst > 0 )
                System.out.println("数据添加成功！");
            else
                System.out.println("数据添加失败！");

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

ResultSet：结果集对象,封装查询结果
1. boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true
2. getXxx(参数):获取数据，Xxx：代表数据类型如： int getInt() , String getString()
  1. 参数：
    1. int：代表列的编号,从1开始如： getString(1)
    2. String：代表列名称。如： getDouble(“balance”)
  - 注意：
    - 使用步骤：
      1. 游标向下移动一行
      2. 判断是否有数据
      3. 获取数据

/** * 实现：打印表中数据 */
public class JDBCDemo4 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement statement = null;
        //0.注册jar
        try {
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.
                    getConnection("jdbc:mysql:///db1", "root", "809080");
            //3.定义sql
            String sql = "select * FROM account";
            //4.获取sql执行对象
            statement = conn.createStatement();
            //5.执行sql返回结果
            ResultSet resultSet = statement.executeQuery(sql);
            //6.处理结果
            //6.1获取结果集
            //6.2游标下移
            while (resultSet.next()){  //结果集是否有下一个
                int id = resultSet.getInt(1);
                String name = resultSet.getString("name");
                double balance = resultSet.getDouble("balance");
                System.out.println("id = " + id +  "---name = " + name +"---工资 = " + balance);
            }

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

案例1：封装JDBCUtiles工具类 ==> 打印表格
配置文件：

driver=com.mysql.jdbc.Driver
user=root
password=809080
url=jdbc:mysql:///db1
## 注意配置文件最好不要加分号和""表示字符串

工具类实现：

public class JDBCUtils {
   
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    
    //静态代码块，在工具类加载的时候jdbc.properties只会被加载一次
    static{
   
        try {
   
            //1. 创建Properties集合类。
            Properties pro = new Properties();
            //2.获取src路径下的文件的方式--->ClassLoader 类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            //3.获取url
            URL resource = classLoader.getResource("jdbc.properties");
            //4.URL转换成字符串路径
            String path = resource.getPath();
            //5.加载文件
            pro.load(new FileReader(path));
            //6.获取数据，赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            //10.注册驱动
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
   
            e.printStackTrace();
        } catch (FileNotFoundException e) {
   
            e.printStackTrace();
        } catch (IOException e) {
   
            e.printStackTrace();
        }
    };

    /** * 获取数据库连接对象 * @return */
    public static  Connection getConnection(){
   
        //1.注册驱动
        try {
   
            //2.获取连接
            return  DriverManager.
                    getConnection(url, user, password);
        } catch (SQLException e) {
   
            e.printStackTrace();
        }
        return  null;
    }
    /** * 释放资源 * @param resultSet * @param conn * @param statement */
    public  static void close(ResultSet resultSet,Connection conn, Statement statement){
   
        if(conn != null) {
   
            try {
   
                conn.close();
            } catch (SQLException e) {
   
                e.printStackTrace();
            }
        }
        if(statement != null) {
   
            try {
   
                statement.close();
            } catch (SQLException e) {
   
                e.printStackTrace();
            }
        }
        if(resultSet != null) {
   
            try {
   
                resultSet.close();
            } catch (SQLException e) {
   
                e.printStackTrace();
            }
        }
    }
}

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 -- 所在部门编号
);

-- 添加员工
INSERT INTO emp(id,ename,job_id,mgr,joindate,salary,bonus,dept_id) VALUES 
(1001,'孙悟空',4,1004,'2000-12-17','8000.00',NULL,20),
(1002,'卢俊义',3,1006,'2001-02-20','16000.00','3000.00',30),
(1003,'林冲',3,1006,'2001-02-22','12500.00','5000.00',30),
(1004,'唐僧',2,1009,'2001-04-02','29750.00',NULL,20),
(1005,'李逵',4,1006,'2001-09-28','12500.00','14000.00',30),
(1006,'宋江',2,1009,'2001-05-01','28500.00',NULL,30),
(1007,'刘备',2,1009,'2001-09-01','24500.00',NULL,10),
(1008,'猪八戒',4,1004,'2007-04-19','30000.00',NULL,20),
(1009,'罗贯中',1,NULL,'2001-11-17','50000.00',NULL,10),
(1010,'吴用',3,1006,'2001-09-08','15000.00','0.00',30),
(1011,'沙僧',4,1004,'2007-05-23','11000.00',NULL,20),
(1012,'李逵',4,1006,'2001-12-03','9500.00',NULL,30),
(1013,'小白龙',4,1004,'2001-12-03','30000.00',NULL,20),
(1014,'关羽',4,1007,'2002-01-23','13000.00',NULL,10);

SELECT * FROM emp;

Emp员工类：

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

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

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

测试类：

public class JDBCDemo6 {
   
    public static void main(String[] args) {
   
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        //0.准备集合
        List<Emp>  emps = new ArrayList<Emp>();
        Emp emp = null;
        //1.导入jar包
        try {
   
            //2.定义sql
            String sql = "select * from emp";
            //3.获取数据库连接
            connection = JDBCUtils.getConnection();
            //4.获取执行sql对象
            statement = connection.createStatement();
            //5.执行sql
            resultSet = statement.executeQuery(sql);
            //6.处理结果
            while(resultSet.next()){
   
                 int id = resultSet.getInt("id");
                 String ename = resultSet.getString("ename");
                 int job_id = resultSet.getInt("job_id");
                 Date joindate = resultSet.getDate("joindate");
                 double salary = resultSet.getDouble("salary");
                 double bonus = resultSet.getDouble("bonus");
                 int dept_id = resultSet.getInt("dept_id");

                 //赋值
                emp = new Emp();
                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);
                //装载集合
                emps.add(emp);
            }
            System.out.println(emps);
        }catch (SQLException e) {
   
            e.printStackTrace();
        }finally {
   
            JDBCUtils.close(resultSet,connection,statement);
        }
    }
}

案例2：模拟登录

/** * 实现：模拟控制台输入账号+密码连接数据库登录 */
public class JDBCDemo7 {
   
    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 login = new JDBCDemo7().login(username, password);
        if(login)
            System.out.println("登录成功！");
        else
            System.out.println("账号或密码错误");

    }

    public boolean login(String username,String password){
   
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
            if(username == null && password == null)
                return false;
        try {
   
            connection = JDBCUtils.getConnection();
            statement = connection.createStatement();
            String sql = "select *from user where username = '"+username+"' and password = '"+password+"';";
            resultSet = statement.executeQuery(sql);

            return resultSet.next();  //结果集不为空表示查找到了

        }catch (SQLException e) {
   
            e.printStackTrace();
        }finally {
   
            JDBCUtils.close(resultSet,connection,statement);
        }
            return false;
    }
}

PreparedStatement：执行sql的对象
引入SQL注入：SQL注入的本质就是利用SQL语法本身的漏洞，绕过系统的检测，入侵后台数据库的操作。
例如上述案例2，可以利用非法密码：a’ or ‘a’ = 'a
构成的SQL语句是：select * from user where username = ‘fhdsjkf’ and password = ‘a’ or ‘a’ = ‘a’
解决sql注入问题：使用PreparedStatement对象来解决，本质是利用预编译的SQL：参数使用?作为占位符,然后通过赋值?的方式进行动态的赋值。

步骤：
1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.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. 释放资源

修改上述案例2，解决SQ存在的注入问题

/** * 实现：模拟控制台输入账号+密码连接数据库登录 */
public class JDBCDemo7 {
   
    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 login = new JDBCDemo7().login2(username, password);
        if(login)
            System.out.println("登录成功！");
        else
            System.out.println("账号或密码错误");

    }
    /** * 使用了PreparedStatement对象解决了SQL注入问题 * @param username * @param password * @return */
    public boolean login2(String username,String password){
   
        Connection connection = null;
        PreparedStatement psmt = null;
        ResultSet resultSet = null;
        if(username == null && password == null)
            return false;
        try {
   
            connection = JDBCUtils.getConnection();
            //赋值语句使用?替换
            String sql = "select *from user where username = ? and password = ?;";
            psmt = connection.prepareStatement(sql);
            //为?赋值
            psmt.setString(1,username);
            psmt.setString(2,password);
            resultSet = psmt.executeQuery();

            return resultSet.next();  //结果集不为空表示查找到了

        }catch (SQLException e) {
   
            e.printStackTrace();
        }finally {
   
            JDBCUtils.close(resultSet,connection,psmt);
        }
        return false;
    }
}

注意：后期都会使用PreparedStatement来完成增删改查的所有操作
1. 可以防止SQL注入
2. 效率更高

JDBC控制事务

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

/** 使用db1中的account表 * JDBC控制事务，如果出现异常情况，通过回滚事务达到数据的安全性 */
public class JDBCDemo8 {
   
    public static void main(String[] args) {
   

        Connection connection = null;
        PreparedStatement psmt1 = null;
        PreparedStatement psmt2 = null;
        try {
   
            //获取连接
            connection = JDBCUtils.getConnection();
            //开启事务
            connection.setAutoCommit(false);

            //定义sql
            String sql_1 = "update account set balance = balance -? where id = ?;";
            String sql_2 = "update account set balance = balance +? where id = ?;";
            //获取
            psmt1 = connection.prepareStatement(sql_1);
            int i = 3/0 ;  //制造异常
            psmt2 = connection.prepareStatement(sql_2);

            //给?赋值
            psmt1.setDouble(1,500);
            psmt1.setInt(2,1);
            psmt2.setDouble(1,500);
            psmt2.setInt(2,2);

            psmt1.executeUpdate();
            psmt2.executeUpdate();

            //提交事务
            connection.commit();
            

        } catch (SQLException e) {
   
            e.printStackTrace();
        }finally {
   
            try {
   
                if(connection != null)
                connection.rollback();
            } catch (SQLException e) {
   
                e.printStackTrace();
            }
            JDBCUtils.close(null,connection,psmt1);
            JDBCUtils.close(null,connection,psmt2);
        }
    }
}

数据库连接池

1、概念：其实就是一个集合，存放数据库连接的容器。
当系统初始化好后，容器会被创建成功，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象返回给容器。
2、好处：

节约资源
用户访问高效

3、实现：

标准接口：：DataSource javax.sql包下的
1. 方法：
* 获取连接：getConnection()
* 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接
一般不去实现它，由数据库厂商来实现它

C3P0：数据库连接池技术
- 步骤：
  1. 导入jar包 (两个) 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 class C3P0Demo1 {
   
   public static void main(String[] args) throws SQLException {
   
       //1.创建数据数据库连接池对象
       DataSource ds = new ComboPooledDataSource();
       for(int i = 0;i < 11;i++) {
   
           //2.获取连接对象
           Connection conn = ds.getConnection();
           System.out.println(i + ":"+conn);
       }
   }
}

Druid：数据库连接池实现技术，由阿里巴巴提供的
1. 步骤：
  1. 导入jar包 druid-1.0.9.jar
  2. 定义配置文件：
    - 是properties形式的
    - 可以叫任意名称，可以放在任意目录下
  3. 加载配置文件。Properties
  4. 获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
  5. 获取连接：getConnection

	/* 测试Demo: */
public class DruidDemo1 {
   
    public static void main(String[] args) throws Exception {
   

        //1.导入jar包
        //2.加载配置文件
        Properties pro = new Properties();
        ClassLoader cls = DruidDemo1.class.getClassLoader();
        InputStream is = cls.getResourceAsStream("druid.properties");
        pro.load(is);
        //3.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //4.获取连接对象
        for(int i = 0;i<10;i++){
   
            Connection conn = ds.getConnection();
            System.out.println(i + ":"+conn);
        }
    }
}

案例：封装DruidUtils并测试数据库

public class DruidUtils {
   
    private static DataSource ds;
    static{
   
        try {
   
            //加载jar包
            //加载配置文件
            Properties pro = new Properties();
            ClassLoader classLoader = DruidUtils.class.getClassLoader();
            InputStream is = classLoader.getResourceAsStream("druid.properties");
            pro.load(is);
            //获取DateSourse
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
   
            e.printStackTrace();
        } catch (Exception e) {
   
            e.printStackTrace();
        }
        //
    };
    /** * 释放资源 * @param statement * @param conn * @param resultSet */
    public  static void close(Statement statement, Connection conn, ResultSet resultSet){
   
        if(conn != null) {
   
            try {
   
                conn.close();
            } catch (SQLException e) {
   
                e.printStackTrace();
            }
        }
        if(statement != null) {
   
            try {
   
                statement.close();
            } catch (SQLException e) {
   
                e.printStackTrace();
            }
        }
        if(resultSet != null) {
   
            try {
   
                resultSet.close();
            } catch (SQLException e) {
   
                e.printStackTrace();
            }
        }
    }
    /** * 获取连接 * @return */
    public static Connection getConnection(){
   
        try {
   
            return ds.getConnection();
        } catch (SQLException e) {
   
            e.printStackTrace();
        }
        return null;
    }
}

测试插入account表一条记录

public class DruidDemo2 {
   
    public static void main(String[] args) {
   
        PreparedStatement preparedStatement = null;
        Connection conn = null;
        try {
   
            //1.获取连接
            conn = DruidUtils.getConnection();
            //2.定义sql
            String sql = "insert into account value(null,?,?)";
            preparedStatement = conn.prepareStatement(sql);
            //3.为?赋值
            preparedStatement.setString(1,"jaychou");
            preparedStatement.setDouble(2,999999);
            //4.执行
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
   
            e.printStackTrace();
        }finally {
   
        	//5.释放资源
            DruidUtils.close(preparedStatement,conn,null);
        }
    }
}

Spring JDBC

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤：
1. 导入jar包(5个)
2. 创建JdbcTemplate对象。依赖于数据源DataSource(可以从DruidUtiles获取)
  - 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：查询结果，将结果封装为对象
    - 一般用于聚合函数的查询
4. 练习：
  - 需求：
    1. 修改1号数据的 salary 为 10000
    2. 添加一条记录
    3. 删除刚才添加的记录
    4. 查询id为1的记录，将其封装为Map集合
    5. 查询所有记录，将其封装为List
    6. 查询所有记录，将其封装为Emp对象的List集合
    7. 查询总记录数

package jdbctemplate;

import druid.DruidUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import utils.JDBCUtils;

import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/** * * 需求： 1. 修改1号数据的 salary 为 10000 2. 添加一条记录 3. 删除刚才添加的记录 4. 查询id为1的记录，将其封装为Map集合 5. 查询所有记录，将其封装为List 6. 查询所有记录，将其封装为Emp对象的List集合 7. 查询总记录数 */
public class TemplateDemo2 {
   

    private JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidUtils.getDataSource());

    //1.修改1号数据的 salary 为 10000
    @Test
    public void test01(){
   
        String sql = "update emp set salary = 10000 where id =?";
        int rst = jdbcTemplate.update(sql, 1001);
        System.out.println(rst);
    }

    //2.添加一条记录
    @Test
    public void test02(){
   
        String sql = "insert into emp (id,ename,dept_id)VALUE (?,?,?)";
        int rst = jdbcTemplate.update(sql, 100100,"liuzeyu",4545);
        System.out.println(rst);
    }

    //3.删除刚才添加的记录
    @Test
    public void test03(){
   
        String sql = "DELETE from emp where id = ?";
        int rst = jdbcTemplate.update(sql, 100100);
        System.out.println(rst);
    }
    /** * 4.查询id为1001的记录，将其封装为Map集合 * 注意：这个方法查询的结果集长度只能是1 */
    @Test
    public void test04(){
   
        String sql = "select * from emp where id = ? ";
        Map<String, Object> rst = jdbcTemplate.queryForMap(sql, 1001);
        System.out.println(rst);
    }
    /** * 5.查询所有记录，将其封装为List */
    @Test
    public void test05(){
   
        String sql = "select * from emp";
        /** * List里面装载多个Map */
        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
        for (Map<String, Object> stringObjectMap : list) {
   
            System.out.println(stringObjectMap);
        }
    }
    /** * 6. 查询所有记录，将其封装为Emp对象的List集合 */
    @Test
    public void test06(){
   
        String sql = "select * from emp";
        List<Emp> empList = jdbcTemplate.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");
                Date joindate = rs.getDate("joindate");
                double salary = rs.getDouble("salary");
                double bonus = rs.getDouble("bonus");
                int dept_id = rs.getInt("dept_id");

                //赋值个Emp
                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);
                return emp;
            }
        });
        for (Emp list : empList) {
   
            System.out.println(list);
        }
    }

    /** * 6. 查询所有记录，将其封装为Emp对象的List集合 * 这里要注意类型转换==>要统一将基本类型转换成包装类型 */
    @Test
    public void test06_2(){
   
        String sql = "select * from emp";
        List<Emp> empList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : empList) {
   
            System.out.println(emp);
        }
    }

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

本教程只适合快速入门学习，如有错误欢迎指正。