Java web笔记：第04章_JDBC

准图灵奖得主

已于 2022-06-07 18:19:02 修改

阅读量367

点赞数

于 2022-06-03 22:05:51 首次发布

本文为博主原创文章，未经允许不得转载。如有问题，欢迎指正！

本文链接：https://blog.csdn.net/iamlsl/article/details/125110143

版权

Java web笔记专栏收录该内容

7 篇文章 3 订阅

订阅专栏

Java web笔记——JDBC的使用

1. JDBC基本概念
2. JDBC连接数据库
- - 2.1 步骤
  - 2.2 代码实现
3. JDBC中各个接口和类
4. 抽取JDBC工具类： JDBCUtils
5.JDBC控制事务
- - 5.1 复习事务
  - 5.2 JDBC控制事务示例代码
6. 数据库连接池
7. Spring JDBC

说明：本内容整理自B站黑马程序员Java web课程视频及文档>>B站黑马程序员Java web课程视频

1. JDBC基本概念

在这里插入图片描述

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

2. JDBC连接数据库

2.1 步骤

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

2.2 代码实现

JDBC连接数据库代码实现

package cn.itcast.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
/**
 * 代码实现：
 //1. 导入驱动jar包
 //2.注册驱动
 Class.forName("com.mysql.jdbc.Driver");
 //3.获取数据库连接对象
 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
 //4.定义sql语句
 String sql = "update account set balance = 500 where id = 1";
 //5.获取执行sql的对象 Statement
 Statement stmt = conn.createStatement();
 //6.执行sql
 int count = stmt.executeUpdate(sql);
 //7.处理结果
 System.out.println(count);
 //8.释放资源
 stmt.close();
 conn.close();
 */
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/db3", "root", "root");

 Connection conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  /*
   DriverManager.getConnection参数说明
                 url:  "jdbc:mysql:///db3"
                user:  "root"
            password:  "root"
   */
 //4.定义sql语句
//String sql = "update account set balance = 2000 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();
 }
}

3. JDBC中各个接口和类

3.1 DriverManager：驱动管理类

DriverManager——驱动管理类

3.1.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!");
         }
 	}
 注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。

3.1.2 DriverManager作用二：获取数据库连接

方法：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：数据库连接对象

3.2.1 Connection作用一：获取执行sql 的对象

   //Connection功能一：获取执行sql 的对象
    Statement createStatement()
    PreparedStatement prepareStatement(String sql)

3.2.2 Connection作用二：管理事务

//Connection功能二：管理事务
 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
	 提交事务：commit() 
 回滚事务：rollback()

3.3 Statement：执行sql的对象

3.3.1 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)语句

3.3.2 Statement练习

Statement练习：
1. account表 添加一条记录
2. account表 修改记录
3. account表 删除一条记录

代码：
Statement stmt = null;
   Connection conn = null;
   try {
       //1. 注册驱动
       Class.forName("com.mysql.jdbc.Driver");
       //2. 定义sql
       String sql = "insert into account values(null,'王五',3000)";
       //3.获取Connection对象
       conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
       //4.获取执行sql的对象 Statement
       stmt = conn.createStatement();
       //5.执行sql
       int count = stmt.executeUpdate(sql);//影响的行数
       //6.处理结果
       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 {
       //stmt.close();
       //7. 释放资源
       //避免空指针异常
       if(stmt != null){
           try {
               stmt.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }

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

3.4 ResultSet：结果集对象,封装查询结果

3.4.1 ResultSet作用——封装查询结果

boolean next(): 
游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，
如果是，则返回false，如果不是则返回true

      getXxx(参数):获取数据
	Xxx：代表数据类型   如： int getInt() ,	String getString()
	参数：
		1. int：代表列的编号,从1开始   如： getString(1)
		2. String：代表列名称。 如： getDouble("balance")
    getXxx(参数)函数通常存在重载的情况： 如getString(1)、getString("name")
 
 注意：
	使用步骤：
		1.游标向下移动一行
		2.判断是否有数据
		3.获取数据

	   //循环判断游标是否是最后一行末尾。
           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);
           }

3.4.2 ResultSet代码示例一

处理查询结果

Connection conn = null;
  Statement stmt = null;
  ResultSet rs = null;
  try {
      //1. 注册驱动
      Class.forName("com.mysql.jdbc.Driver");
      //2.获取连接对象
      conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
      //3.定义sql
      String sql  = "select * from account";
      //4.获取执行sql对象
      stmt = conn.createStatement();
      //5.执行sql
      rs = stmt.executeQuery(sql);
      //6.处理结果
      //6.1 让游标向下移动一行
      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);


      //6.1 让游标向下移动一行
      rs.next();
      //6.2 获取数据
      int id2 = rs.getInt(1);
      String name2 = rs.getString("name");
      double balance2 = rs.getDouble(3);

      System.out.println(id2 + "---" + name2 + "---" + balance2);

      //6.1 让游标向下移动一行
      rs.next();
      //6.2 获取数据
      int id3 = rs.getInt(1);
      String name3 = rs.getString("name");
      double balance3 = rs.getDouble(3);

      System.out.println(id3 + "---" + name3 + "---" + balance3);


  } catch (ClassNotFoundException e) {
      e.printStackTrace();
  } catch (SQLException e) {
      e.printStackTrace();
  } finally {
      //7.释放资源

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

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

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

3.4.2 ResultSet代码示例二

处理结果时循环判断游标是否是最后一行末尾

 Connection conn = null;
 Statement stmt = null;
 ResultSet rs = null;
 try {
     //1. 注册驱动
     Class.forName("com.mysql.jdbc.Driver");
     //2.获取连接对象
     conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
     //3.定义sql
     String sql  = "select * from account";
     //4.获取执行sql对象
     stmt = conn.createStatement();
     //5.执行sql
     rs = stmt.executeQuery(sql);
     //6.处理结果
     //循环判断游标是否是最后一行末尾。
     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 e) {
     e.printStackTrace();
 } finally {
     //7.释放资源

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

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

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

3.4.3 ResultSet练习题

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

一、Emp类定义

package cn.itcast.domain;
import java.util.Date;
/**
 * 封装Emp表数据的JavaBean
*/
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 int getDept_id() {
    return dept_id;
}

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


public double getBonus() {
    return bonus;
}

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


@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 +
            '}';
}
}

二、定义方法 public List findAll(){}
三、实现方法 select * from emp;

package cn.itcast.jdbc;
import cn.itcast.domain.Emp;
import cn.itcast.util.JDBCUtils;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
*/
public class JDBCDemo8 {

public static void main(String[] args) {
    List<Emp> list = new JDBCDemo8().findAll();
    System.out.println(list);
    System.out.println(list.size());
}
  /**
 * 查询所有emp对象
 * @return
 */
public List<Emp> findAll(){
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    List<Emp> list = null;
    try {
        //1.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.获取连接
        conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
        //3.定义sql
        String sql = "select * from emp";
        //4.获取执行sql的对象
        stmt = conn.createStatement();
        //5.执行sql
        rs = stmt.executeQuery(sql);
        //6.遍历结果集，封装对象，装载集合
        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 e) {
        e.printStackTrace();
    }finally {
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

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

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

3.5 PreparedStatement：执行sql的对象

3.5.1 PreparedStatement解决SQL注入问题

1. SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
		1. 输入用户随便，输入密码：a' or 'a' = 'a
		2. sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a' 

	2. 解决sql注入问题：使用PreparedStatement对象来解决
	3. 预编译的SQL：参数使用?作为占位符
	4. 步骤：
		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. 释放资源

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

3.5.2 PreparedStatement解决SQL示例代码

见 4.4.2 实现代码中PreparedStatement部分

4. 抽取JDBC工具类： JDBCUtils

4.1 JDBC工具类作用

抽取JDBC工具类的目的：简化代码，提高可重用性

需求：

1.抽取注册驱动
2.抽取一个方法获取连接对象
- 不想传递参数（麻烦），还得保证工具类的通用性；解决方案：配置文件
3.抽取一个方法释放资源

4.2 JDBC工具类抽取示例代码

package cn.itcast.util;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;
/**
* JDBC工具类
*/
public class JDBCUtils {
private static String url;
private static String user;
private static String password;
private static String driver;
/**
 * 文件的读取，只需要读取一次即可拿到这些值。使用静态代码块
 */
static{
    /*
         配置文件jdbc.properties内容：
         url=jdbc:mysql:///db3
	     user=root
	     password=root
	     driver=com.mysql.jdbc.Driver
     */
    //读取资源文件，获取值。
    try {
        //1. 创建Properties集合类。
        Properties pro = new Properties();

        //获取src路径下的文件的方式--->ClassLoader 类加载器
        ClassLoader classLoader = JDBCUtils.class.getClassLoader();
        URL res  = classLoader.getResource("jdbc.properties");
        String path = res.getPath();
       // System.out.println(path);///D:/IdeaProjects   /itcast/out/production/day04_jdbc/jdbc.properties
        //2. 加载文件
       // pro.load(new FileReader("D:\\IdeaProjects\\itcast\\day04_jdbc\\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 e) {
            e.printStackTrace();
        }
    }

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


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

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

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

4.3 测试JDBCUtils示例代码

package cn.itcast.jdbc;

import cn.itcast.domain.Emp;
import cn.itcast.util.JDBCUtils;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
 * * 定义一个方法，查询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());
    }

/**
 * 演示JDBC工具类
 * @return
 */
public List<Emp> findAll2(){
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    List<Emp> list = null;
    try {
       /* //1.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.获取连接
        conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");*/
        conn = JDBCUtils.getConnection();
        //3.定义sql
        String sql = "select * from emp";
        //4.获取执行sql的对象
        stmt = conn.createStatement();
        //5.执行sql
        rs = stmt.executeQuery(sql);
        //6.遍历结果集，封装对象，装载集合
        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 (SQLException e) {
        e.printStackTrace();
    }finally {
        JDBCUtils.close(rs,stmt,conn);
    }
    return list;
}
}

4.4 JDBC练习

4.4.1 需求&方案步骤

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

* 步骤：
	1. 创建数据库表 user
		CREATE TABLE USER(
			id INT PRIMARY KEY AUTO_INCREMENT,
			username VARCHAR(32),
			PASSWORD VARCHAR(32)
		
		);

		INSERT INTO USER VALUES(NULL,'zhangsan','123');
		INSERT INTO USER VALUES(NULL,'lisi','234');

   	 2.代码实现：
    public class JDBCDemo9 {
    public static void main(String[] args) {
    //1.键盘录入，接受用户名和密码
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入用户名：");
    String username = sc.nextLine();
    System.out.println("请输入密码：");
    String password = sc.nextLine();
    //2.调用方法
    boolean flag = new JDBCDemo9().login(username, password);
    //3.判断结果，输出不同语句
    if(flag){
        //登录成功
        System.out.println("登录成功！");
    }else{
        System.out.println("用户名或密码错误！");
    }
     }

4.4.2 实现代码

package cn.itcast.jdbc;
import cn.itcast.util.JDBCUtils;
import java.sql.*;
import java.util.Scanner;
/**
* 练习：
 * 		* 需求：
 * 			1. 通过键盘录入用户名和密码
 * 			2. 判断用户是否登录成功
*/
     public class JDBCDemo9 {
     public static void main(String[] args) {
		        //1.键盘录入，接受用户名和密码
		        Scanner sc = new Scanner(System.in);
		        System.out.println("请输入用户名：");
		        String username = sc.nextLine();
		        System.out.println("请输入密码：");
		        String password = sc.nextLine();
		        //2.调用方法
		        boolean flag = new JDBCDemo9().login2(username, password);
		        //3.判断结果，输出不同语句
		        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;
    //1.获取连接
    try {
        conn =  JDBCUtils.getConnection();
        //2.定义sql
        String sql = "select * from user where username = '"+username+"' and password = '"+password+"' ";
        System.out.println(sql);
        //3.获取执行sql的对象
        stmt = conn.createStatement();
        //4.执行查询
        rs = stmt.executeQuery(sql);
        //5.判断
       return rs.next();//如果有下一行，则返回true

    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        JDBCUtils.close(rs,stmt,conn);
    }
    return false;
}
/**
 * 登录方法,使用PreparedStatement实现
 */
public boolean login2(String username ,String password){
    if(username == null || password == null){
        return false;
    }
    //连接数据库判断是否登录成功
    Connection conn = null;
    PreparedStatement pstmt =  null;
    ResultSet rs = null;
    //1.获取连接
    try {
        conn =  JDBCUtils.getConnection();
        //2.定义sql
        String sql = "select * from user where username = ? and password = ?";
        //3.获取执行sql的对象
        pstmt = conn.prepareStatement(sql);
        //给?赋值
        pstmt.setString(1,username);
        pstmt.setString(2,password);
        //4.执行查询,不需要传递sql
        rs = pstmt.executeQuery();
        //5.判断
        return rs.next();//如果有下一行，则返回true

    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        JDBCUtils.close(rs,pstmt,conn);
    }
    
    return false;
}
}

5.JDBC控制事务

5.1 复习事务

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

5.2 JDBC控制事务示例代码

  package cn.itcast.jdbc;
       import cn.itcast.util.JDBCUtils;
       import java.sql.Connection;
       import java.sql.PreparedStatement;
       import java.sql.SQLException;
       /**
        * 事务操作：通过制造异常查看数据是否变化
        */
    public class JDBCDemo10 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pstmt1 = null;
        PreparedStatement pstmt2 = null;

        try {
            //1.获取连接
            conn = JDBCUtils.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 (Exception e) {
            //事务回滚
            try {
                if(conn != null) {
                    conn.rollback();
                }
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            JDBCUtils.close(pstmt1,conn);
            JDBCUtils.close(pstmt2,null);
        }


     }
        }

6. 数据库连接池

6.1 简介

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

2.好处：
	1.节约资源
	2.用户访问高效

3.实现：
	1.标准接口：DataSource   javax.sql包下的
		1.javax.sql包下的方法：
			
			获取连接：getConnection()
			
			归还连接：
			Connection.close()。如果连接对象Connection是从连接池中获取的，
			那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接

2.一般我们不去实现它，由数据库厂商来实现
		1.C3P0：数据库连接池技术（此技术较早）
		2.Druid：数据库连接池实现技术，由阿里巴巴提供的（此技术比较新、性能很高）

6.2 C3P0：数据库连接池技术

6.2.1 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

* 代码：
//1.创建数据库连接池对象
            DataSource ds  = new ComboPooledDataSource();
   //2. 获取连接对象
            Connection conn = ds.getConnection();

6.2.2 C3P0配置文件说明

C3P0配置文件c3p0-config.xml 及注释说明

   <c3p0-config>
  <!-- 使用默认的配置读取连接池对象 -->
  <default-config>
  	<!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <!-- 连接池参数 -->
    <!--初始化申请的连接数量-->
    <property name="initialPoolSize">5</property>
    <!--最大的连接数量-->
    <property name="maxPoolSize">10</property>
    <!--超时时间-->
    <property name="checkoutTimeout">3000</property>
  </default-config>

  <named-config name="otherc3p0"> 
    <!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3</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>

6.2.2 C3P0示例代码

代码一：获取链接的测试

package cn.itcast.datasource.c3p0;	
import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/**
 * c3p0的演示
 */
public class C3P0Demo1 {
    public static void main(String[] args) throws SQLException {
        //1.创建数据库连接池对象
        DataSource ds  = new ComboPooledDataSource();
        //2. 获取连接对象
        Connection conn = ds.getConnection();

        //3. 打印对象
        System.out.println(conn);

    }
}

代码二：归还连接

package cn.itcast.datasource.c3p0;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/**
 * c3p0演示
 */
public class C3P0Demo2 {

    public static void main(String[] args) throws SQLException {
       /* //1. 获取DataSource，使用默认配置
        DataSource ds  = new ComboPooledDataSource();

        //2.获取连接

        for (int i = 1; i <= 11 ; i++) {
            Connection conn = ds.getConnection();
            System.out.println(i+":"+conn);

            if(i == 5){
                conn.close();//归还连接到连接池中
            }
        }*/

        //testNamedConfig();

    }
    
    public static void testNamedConfig() throws SQLException {
        // 1.1 获取DataSource，使用指定名称配置
        DataSource ds  = new ComboPooledDataSource("otherc3p0");
        //2.获取连接
        for (int i = 1; i <= 10 ; i++) {
            Connection conn = ds.getConnection();
            System.out.println(i+":"+conn);
        }
    }
  }

6.3 Druid：数据库连接池实现技术，由阿里巴巴提供的

6.3.1 Druid使用说明

1. 步骤：
		1. 导入jar包 druid-1.0.9.jar
		2. 定义配置文件：
			* 是properties形式的
			* 可以叫任意名称，可以放在任意目录下
		3. 加载配置文件。Properties
		4. 获取数据库连接池对象：通过工厂类来获取  DruidDataSourceFactory
		5. 获取连接：getConnection
	* 代码：
		 //3.加载配置文件
        Properties pro = new Properties();
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //4.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //5.获取连接
        Connection conn = ds.getConnection();

6.3.2 Druid代码示例一

获取连接实现

package cn.itcast.datasource.druid;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
/**
 * Druid演示
 */
public class DruidDemo {
    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //3.加载配置文件
        /*   配置文件druid.properties内容
	        driverClassName=com.mysql.jdbc.Driver
			url=jdbc:mysql:///db3
			username=root
			password=root
			initialSize=5
			maxActive=10
			maxWait=3000
         */
        Properties pro = new Properties();
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //4.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //5.获取连接
        Connection conn = ds.getConnection();
        System.out.println(conn);
    }
}

6.3.3 Druid代码示例二

Druid工具类抽取

 /* 2. 定义工具类
			1. 定义一个类 JDBCUtils
			2. 提供静态代码块加载配置文件，初始化连接池对象
			3. 提供方法
				1. 获取连接方法：通过数据库连接池获取连接
				2. 释放资源
				3. 获取连接池的方法  */
package cn.itcast.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;

/**
 * Druid连接池的工具类
 */
public class JDBCUtils {

    //1.定义成员变量 DataSource
    private static DataSource ds ;
    
  // 提供静态代码块加载配置文件，初始化连接池对象
    static{
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //2.获取DataSource
            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){
       /* if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(conn != null){
            try {
                conn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }*/

       close(null,stmt,conn);
    }


    public static void close(ResultSet rs , Statement stmt, Connection conn){


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


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

        if(conn != null){
            try {
                conn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取连接池方法
     */

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

6.3.4 Druid代码示例三

使用新的工具类

package cn.itcast.datasource.druid;

import cn.itcast.utils.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
 * 使用新的工具类
 */
public class DruidDemo2 {

    public static void main(String[] args) {
        /*
         * 完成添加操作：给account表添加一条记录
         */
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            //1.获取连接
            conn = JDBCUtils.getConnection();
            //2.定义sql
            String sql = "insert into account values(null,?,?)";
            //3.获取pstmt对象
            pstmt = conn.prepareStatement(sql);
            //4.给？赋值
            pstmt.setString(1,"王五");
            pstmt.setDouble(2,3000);
            //5.执行sql
            int count = pstmt.executeUpdate();
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //6. 释放资源
            JDBCUtils.close(pstmt,conn);
        }
    }
 }

7. Spring JDBC

7.1 Spring JDBC的使用

 Spring框架对JDBC的简单封装。 Spring框架提供了一个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：查询结果，将结果封装为对象
			  一般用于聚合函数的查询

7.2 示例代码一

Spring JDBC会自动地释放资源、归还连接，写程序时只需关心如何定义SQL, 执行SQL

package cn.itcast.jdbctemplate;

import cn.itcast.utils.JDBCUtils;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * JdbcTemplate入门
 */
public class JdbcTemplateDemo1 {

    public static void main(String[] args) {
        //1.导入jar包
        //2.创建JDBCTemplate对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //3.调用方法
        String sql = "update account set balance = 5000 where id = ?";
        int count = template.update(sql, 3);
        System.out.println(count);
    }
}

7.3 Spring JDBC练习示例代码

练习：

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

package cn.itcast.jdbctemplate;

import cn.itcast.domain.Emp;
import cn.itcast.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

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

public class JdbcTemplateDemo2 {

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


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

        //2. 定义sql
        String sql = "update emp set salary = 10000 where id = 1001";
        //3. 执行sql
        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, 1015, "郭靖", 10);
        System.out.println(count);

    }

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

    /**
     * 4.查询id为1001的记录，将其封装为Map集合
     * 注意：这个方法查询的结果集长度只能是1
     */
    @Test
    public void test4(){
        String sql = "select * from emp where id = ? or id = ?";
        Map<String, Object> map = template.queryForMap(sql, 1001,1002);
        System.out.println(map);
        //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}

    }

    /**
     * 5. 查询所有记录，将其封装为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集合
     */

    @Test
    public void test6_2(){
        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 test7(){
        String sql = "select count(id) from emp";
        Long total = template.queryForObject(sql, Long.class);
        System.out.println(total);
    }
    }

说明：本内容整理自B站黑马程序员Java web课程视频及文档>>B站黑马程序员Java web课程视频