1. JDBC快速入门

1.1 jdbc的概念

  • JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系型数据库提供统一访问，它是由一组用Java语言编写的类和接口组成的。

    1.2 jdbc的本质

  • 其实就是java官方提供的一套规范(接口)。用于帮助开发人员快速实现不同关系型数据库的连接！

    1.3 jdbc的快速入门程序(共七步)

  1. 导入jar包

  2. 注册驱动

    1. Class.forName("com.mysql.jdbc.Driver");

  3. 获取连接

    1. Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2", "root", "root");

  4. 获取执行者对象

    1. Statement stat = con.createStatement();

  5. 执行sql语句，并接收返回结果

    1. String sql = "SELECT * FROM user";
    2. ResultSet rs = stat.executeQuery(sql);

  6. 处理结果

    1. while(rs.next()) {
    2.  System.out.println(rs.getInt("id") + "\t" + rs.getString("name"));
    3. }

  7. 释放资源

    1. con.close();
    2. stat.close();
    3. rs.close();

    2. JDBC功能类详解

    2.1 DriverManager

  • DriverManager：驱动管理对象

    • 1.注册驱动(告诉程序该使用哪一个数据库驱动)

      • static void registerDriver(Driver driver)：注册与给定的驱动程序 DriverManager
      • 写代码使用：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. }

      • 注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。在jar包中，存在一个java.sql.Driver配置文件，文件中指定了com.mysql.jdbc.Driver

    • 2.获取数据库连接(获取到数据库的连接并返回连接对象)
      • static Connection getConnection(String url, String user, String password);
        • 返回值：Connection数据库连接对象
        • 参数
          • url：指定连接的路径。语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
          • user：用户名
          • password：密码

            对于这里的驱动管理对象DriveManager，我这里解释一下。 其实我们看到代码会有一种感觉，就是第二步和第三步没有任何关系。其实这是错觉，关系非常大。 首先对于第二步代码Class.forName("com.mysql.jdbc.Driver");其是注册驱动，那注册给谁呢？其实是注册给DriveManager对象了。因此才有了第三步从DriveManager对象中获取到连接对象。 那第二步是怎么完成注册呢？这个就是反射，是对类的主动使用，自然触发JVM的加载链接和初始化。 其中就涉及到了Driver类静态代码的执行，其静态代码上面已经展示了，其内就有向DriveManager对象中注册驱动。

            注意：

            • 因此我们不需要通过DriverManager调用静态方法registerDriver()，因为只要Driver类被使用，则会执行其静态代码块完成注册驱动！
            • mysql5之后的驱动jar包可以省略注册驱动的步骤。在jar包中，存在一个java.sql.Driver配置文件，文件中指定了com.mysql.jdbc.Driver

2.2 Connection

  • Connection：数据库连接对象

    • 获取执行者对象(2种)
      • 获取普通执行者对象：Statement createStatement(); 我们代码就是用的这个方法！
      • 获取预编译执行者对象：PreparedStatement prepareStatement(String sql);
    • 管理事务
      • 开启事务：setAutoCommit(boolean autoCommit); 参数为false，则开启事务。
      • 提交事务：commit();
      • 回滚事务：rollback();
    • 释放资源
      • 立即将数据库连接对象释放：void close();

        2.3 Statement

  • Statement：执行sql语句的对象

    • 执行DML语句：int executeUpdate(String sql);
      • 返回值int：返回影响的行数。
      • 参数sql：可以执行insert、update、delete语句。
    • 执行DQL语句：ResultSet executeQuery(String sql);
      • 返回值ResultSet：封装查询的结果。
      • 参数sql：可以执行select语句。
    • 释放资源
      • 立即将执行者对象释放：void close();

        2.4 ResultSet

  • ResultSet：结果集对象

    • 判断结果集中是否还有数据：boolean next();
      • 有数据返回true，并将索引向下移动一行
      • 没有数据返回false
    • 获取结果集中的数据：XXX getXxx(“列名”);
      • XXX代表数据类型(要获取某列数据，这一列的数据类型)
      • 例如：String getString(“name”); int getInt(“age”);
    • 释放资源
      • 立即将结果集对象释放：void close();

        3. JDBC案例-student学生表的CURD

        3.1 数据准备

  • 数据库和数据表 ```java — 创建db14数据库 CREATE DATABASE db14;

— 使用db14数据库 USE db14;

— 创建student表 CREATE TABLE student( sid INT PRIMARY KEY AUTO_INCREMENT, — 学生id NAME VARCHAR(20), — 学生姓名 age INT, — 学生年龄 birthday DATE — 学生生日 );

— 添加数据 INSERT INTO student VALUES (NULL,’张三’,23,’1999-09-23’),(NULL,’李四’,24,’1998-08-10’),(NULL,’王五’,25,’1996-06-06’),(NULL,’赵六’,26,’1994-10-20’);

  2. - 实体类
  3.    - Student类，自定义类的功能是为了封装表中每列数据，成员变量和列保持一致。
  4.    - 注意：**所有的基本数据类型需要使用包装类，以防null值无法赋值**
  5. ```java
  6. package com.gjt.JDBC02.Domain;/*
  7. @author gaoJunTao
  8. */
  10. import java.util.Date;
  12. public class Student {
  13.     private Integer sid;
  14.     private String name;
  15.     private Integer age;
  16.     private Date birthday;
  18.     public Integer getSid() {
  19.         return sid;
  20.     }
  22.     public void setSid(Integer sid) {
  23.         this.sid = sid;
  24.     }
  26.     public String getName() {
  27.         return name;
  28.     }
  30.     public void setName(String name) {
  31.         this.name = name;
  32.     }
  34.     public Integer getAge() {
  35.         return age;
  36.     }
  38.     public void setAge(Integer age) {
  39.         this.age = age;
  40.     }
  42.     public Date getBirthday() {
  43.         return birthday;
  44.     }
  46.     public void setBirthday(Date birthday) {
  47.         this.birthday = birthday;
  48.     }
  50.     @Override
  51.     public String toString() {
  52.         return "Student{" +
  53.                 "sid=" + sid +
  54.                 ", name='" + name + '\'' +
  55.                 ", age=" + age +
  56.                 ", birthday=" + birthday +
  57.                 '}';
  58.     }
  59. }

3.2 需求一：查询所有学生信息

  • 持久层

    1. /*
    2.    查询所有学生信息
    3. */
    4. @Override
    5. public ArrayList<Student> findAll() {
    6.   ArrayList<Student> list = new ArrayList<>();
    7.   Connection con = null;
    8.   Statement stat = null;
    9.   ResultSet rs = null;
    10.   try{
    11.       //1.注册驱动
    12.       Class.forName("com.mysql.jdbc.Driver");
    14.       //2.获取数据库连接
    15.       con = DriverManager.getConnection("jdbc:mysql://192.168.59.129:3306/db14", "root", "itheima");
    17.       //3.获取执行者对象
    18.       stat = con.createStatement();
    20.       //4.执行sql语句，并且接收返回的结果集
    21.       String sql = "SELECT * FROM student";
    22.       rs = stat.executeQuery(sql);
    24.       //5.处理结果集
    25.       while(rs.next()) {
    26.           Integer sid = rs.getInt("sid");
    27.           String name = rs.getString("name");
    28.           Integer age = rs.getInt("age");
    29.           Date birthday = rs.getDate("birthday");
    31.           //封装Student对象
    32.           Student stu = new Student(sid,name,age,birthday);
    34.           //将student对象保存到集合中
    35.           list.add(stu);
    36.       }
    38.   } catch(Exception e) {
    39.       e.printStackTrace();
    40.   } finally {
    41.       //6.释放资源
    42.       if(con != null) { // 这里为什么要null的判断？？因为这三个变量声明在外边，如果try前面出现异常，则是null
    43.           try {
    44.               con.close();
    45.           } catch (SQLException e) {
    46.               e.printStackTrace();
    47.           }
    48.       }
    50.       if(stat != null) {
    51.           try {
    52.               stat.close();
    53.           } catch (SQLException e) {
    54.               e.printStackTrace();
    55.           }
    56.       }
    58.       if(rs != null) {
    59.           try {
    60.               rs.close();
    61.           } catch (SQLException e) {
    62.               e.printStackTrace();
    63.           }
    64.       }
    65.   }
    66.   //将集合对象返回
    67.   return list;
    68. }

  • 业务层

    1. /*
    2.   查询所有学生信息
    3. */
    4. @Override
    5. public ArrayList<Student> findAll() {
    6.   return dao.findAll();
    7. }

  • 控制层

    1. /*
    2.   查询所有学生信息
    3. */
    4. @Test
    5. public void findAll() {
    6.   ArrayList<Student> list = service.findAll();
    7.   for(Student stu : list) {
    8.       System.out.println(stu);
    9.   }
    10. }

    3.3 需求二：根据id查询学生信息

  • 持久层

    1. /*
    2.   条件查询，根据id查询学生信息
    3. */
    4. @Override
    5. public Student findById(Integer id) {
    6.   Student stu = new Student();
    7.   Connection con = null;
    8.   Statement stat = null;
    9.   ResultSet rs = null;
    10.   try{
    11.       //1.注册驱动
    12.       Class.forName("com.mysql.jdbc.Driver");
    14.       //2.获取数据库连接
    15.       con = DriverManager.getConnection("jdbc:mysql://192.168.59.129:3306/db14", "root", "itheima");
    17.       //3.获取执行者对象
    18.       stat = con.createStatement();
    20.       //4.执行sql语句，并且接收返回的结果集
    21.       String sql = "SELECT * FROM student WHERE sid='"+id+"'";
    22.       rs = stat.executeQuery(sql);
    24.       //5.处理结果集
    25.       while(rs.next()) {
    26.           Integer sid = rs.getInt("sid");
    27.           String name = rs.getString("name");
    28.           Integer age = rs.getInt("age");
    29.           Date birthday = rs.getDate("birthday");
    31.           //封装Student对象
    32.           stu.setSid(sid);
    33.           stu.setName(name);
    34.           stu.setAge(age);
    35.           stu.setBirthday(birthday);
    36.       }
    38.   } catch(Exception e) {
    39.       e.printStackTrace();
    40.   } finally {
    41.       //6.释放资源
    42.       if(con != null) {
    43.           try {
    44.               con.close();
    45.           } catch (SQLException e) {
    46.               e.printStackTrace();
    47.           }
    48.       }
    50.       if(stat != null) {
    51.           try {
    52.               stat.close();
    53.           } catch (SQLException e) {
    54.               e.printStackTrace();
    55.           }
    56.       }
    58.       if(rs != null) {
    59.           try {
    60.               rs.close();
    61.           } catch (SQLException e) {
    62.               e.printStackTrace();
    63.           }
    64.       }
    65.   }
    66.   //将对象返回
    67.   return stu;
    68. }

  • 业务层

    1. /*
    2.   条件查询，根据id查询学生信息
    3. */
    4. @Override
    5. public Student findById(Integer id) {
    6.   return dao.findById(id);
    7. }

  • 控制层

    1. /*
    2.   条件查询，根据id查询学生信息
    3. */
    4. @Test
    5. public void findById() {
    6.   Student stu = service.findById(3);
    7.   System.out.println(stu);
    8. }

    3.4 需求三：新增数据

  • 持久层

    1. /*
    2.     添加学生信息
    3. */
    4. @Override
    5. public int insert(Student stu) {
    6.   Connection con = null;
    7.   Statement stat = null;
    8.   int result = 0;
    9.   try{
    10.       //1.注册驱动
    11.       Class.forName("com.mysql.jdbc.Driver");
    13.       //2.获取数据库连接
    14.       con = DriverManager.getConnection("jdbc:mysql://192.168.59.129:3306/db14", "root", "itheima");
    16.       //3.获取执行者对象
    17.       stat = con.createStatement();
    19.       //4.执行sql语句，并且接收返回的结果集
    20.       Date d = stu.getBirthday();
    21.       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    22.       String birthday = sdf.format(d);
    23.       String sql = "INSERT INTO student VALUES ('"+stu.getSid()+"','"+stu.getName()+"','"+stu.getAge()+"','"+birthday+"')";
    24.       result = stat.executeUpdate(sql);
    26.   } catch(Exception e) {
    27.       e.printStackTrace();
    28.   } finally {
    29.       //6.释放资源
    30.       if(con != null) {
    31.           try {
    32.               con.close();
    33.           } catch (SQLException e) {
    34.               e.printStackTrace();
    35.           }
    36.       }
    38.       if(stat != null) {
    39.           try {
    40.               stat.close();
    41.           } catch (SQLException e) {
    42.               e.printStackTrace();
    43.           }
    44.       }
    45.   }
    46.   //将结果返回
    47.   return result;
    48. }

  • 业务层

    1. /*
    2.   新增学生信息
    3. */
    4. @Override
    5. public int insert(Student stu) {
    6.   return dao.insert(stu);
    7. }

  • 控制层

    1. /*
    2.     新增学生信息
    3. */
    4. @Test
    5. public void insert() {
    6.   Student stu = new Student(5,"周七",27,new Date());
    7.   int result = service.insert(stu);
    8.   if(result != 0) {
    9.       System.out.println("新增成功");
    10.   }else {
    11.       System.out.println("新增失败");
    12.   }
    13. }

    3.5 需求四：修改数据

  • 持久层

    1. /*
    2.   修改学生信息
    3. */
    4. @Override
    5. public int update(Student stu) {
    6.   Connection con = null;
    7.   Statement stat = null;
    8.   int result = 0;
    9.   try{
    10.       //1.注册驱动
    11.       Class.forName("com.mysql.jdbc.Driver");
    13.       //2.获取数据库连接
    14.       con = DriverManager.getConnection("jdbc:mysql://192.168.59.129:3306/db14", "root", "itheima");
    16.       //3.获取执行者对象
    17.       stat = con.createStatement();
    19.       //4.执行sql语句，并且接收返回的结果集
    20.       Date d = stu.getBirthday();
    21.       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    22.       String birthday = sdf.format(d);
    23.       String sql = "UPDATE student SET sid='"+stu.getSid()+"',name='"+stu.getName()+"',age='"+stu.getAge()+"',birthday='"+birthday+"' WHERE sid='"+stu.getSid()+"'";
    24.       result = stat.executeUpdate(sql);
    26.   } catch(Exception e) {
    27.       e.printStackTrace();
    28.   } finally {
    29.       //6.释放资源
    30.       if(con != null) {
    31.           try {
    32.               con.close();
    33.           } catch (SQLException e) {
    34.               e.printStackTrace();
    35.           }
    36.       }
    38.       if(stat != null) {
    39.           try {
    40.               stat.close();
    41.           } catch (SQLException e) {
    42.               e.printStackTrace();
    43.           }
    44.       }
    45.   }
    46.   //将结果返回
    47.   return result;
    48. }

  • 业务层

    1. @Override
    2. public int update(Student stu) {
    3.   return dao.update(stu);
    4. }

  • 控制层

    1. /*
    2.   修改学生信息
    3. */
    4. @Test
    5. public void update() {
    6.   Student stu = service.findById(5);
    7.   stu.setName("周七七");
    9.   int result = service.update(stu);
    10.   if(result != 0) {
    11.       System.out.println("修改成功");
    12.   }else {
    13.       System.out.println("修改失败");
    14.   }
    15. }

    3.6 需求五：删除数据

  • 持久层

    1. /*
    2.   删除学生信息
    3. */
    4. @Override
    5. public int delete(Integer id) {
    6.   Connection con = null;
    7.   Statement stat = null;
    8.   int result = 0;
    9.   try{
    10.       //1.注册驱动
    11.       Class.forName("com.mysql.jdbc.Driver");
    13.       //2.获取数据库连接
    14.       con = DriverManager.getConnection("jdbc:mysql://192.168.59.129:3306/db14", "root", "itheima");
    16.       //3.获取执行者对象
    17.       stat = con.createStatement();
    19.       //4.执行sql语句，并且接收返回的结果集
    20.       String sql = "DELETE FROM student WHERE sid='"+id+"'";
    21.       result = stat.executeUpdate(sql);
    23.   } catch(Exception e) {
    24.       e.printStackTrace();
    25.   } finally {
    26.       //6.释放资源
    27.       if(con != null) {
    28.           try {
    29.               con.close();
    30.           } catch (SQLException e) {
    31.               e.printStackTrace();
    32.           }
    33.       }
    35.       if(stat != null) {
    36.           try {
    37.               stat.close();
    38.           } catch (SQLException e) {
    39.               e.printStackTrace();
    40.           }
    41.       }
    42.   }
    43.   //将结果返回
    44.   return result;
    45. }

  • 业务层

    1. /*
    2.   删除学生信息
    3. */
    4. @Override
    5. public int delete(Integer id) {
    6.   return dao.delete(id);
    7. }

  • 控制层

    1. /*
    2.   删除学生信息
    3. */
    4. @Test
    5. public void delete() {
    6.   int result = service.delete(5);
    8.   if(result != 0) {
    9.       System.out.println("删除成功");
    10.   }else {
    11.       System.out.println("删除失败");
    12.   }
    13. }

    4. JDBC工具类

    4.1 工具类的抽取

  • 配置文件(在src下创建config.properties)

    1. driverClass=com.mysql.jdbc.Driver
    2. url=jdbc:mysql://localhost:3306/db14
    3. username=root
    4. password=root

  • 工具类

    1. /*
    2.   JDBC工具类
    3. */
    4. public class JDBCUtils {
    5.   //1.私有构造方法
    6.   private JDBCUtils(){};
    8.   //2.声明配置信息变量
    9.   private static String driverClass;
    10.   private static String url;
    11.   private static String username;
    12.   private static String password;
    13.   private static Connection con;
    15.   //3.静态代码块中实现加载配置文件和注册驱动
    16.   static{
    17.       try{
    18.           //通过类加载器返回配置文件的字节流
    19.           InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("config.properties");
    21.           //创建Properties集合，加载流对象的信息
    22.           Properties prop = new Properties();
    23.           prop.load(is);
    25.           //获取信息为变量赋值
    26.           driverClass = prop.getProperty("driverClass");
    27.           url = prop.getProperty("url");
    28.           username = prop.getProperty("username");
    29.           password = prop.getProperty("password");
    31.           //注册驱动
    32.           Class.forName(driverClass);
    34.       } catch (Exception e) {
    35.           e.printStackTrace();
    36.       }
    37.   }
    39.   //4.获取数据库连接的方法
    40.   public static Connection getConnection() {
    41.       try {
    42.           con = DriverManager.getConnection(url,username,password);
    43.       } catch (SQLException e) {
    44.           e.printStackTrace();
    45.       }
    47.       return con;
    48.   }
    50.   //5.释放资源的方法
    51.   public static void close(Connection con, Statement stat, ResultSet rs) {
    52.       if(con != null) {
    53.           try {
    54.               con.close();
    55.           } catch (SQLException e) {
    56.               e.printStackTrace();
    57.           }
    58.       }
    60.       if(stat != null) {
    61.           try {
    62.               stat.close();
    63.           } catch (SQLException e) {
    64.               e.printStackTrace();
    65.           }
    66.       }
    68.       if(rs != null) {
    69.           try {
    70.               rs.close();
    71.           } catch (SQLException e) {
    72.               e.printStackTrace();
    73.           }
    74.       }
    75.   }
    77.   public static void close(Connection con, Statement stat) {
    78.       close(con,stat,null);
    79.   }
    80. }

    4.2 使用工具类优化student表的CURD

  • 查询全部

    1. /*
    2.   查询所有学生信息
    3. */
    4. @Override
    5. public ArrayList<Student> findAll() {
    6.   ArrayList<Student> list = new ArrayList<>();
    7.   Connection con = null;
    8.   Statement stat = null;
    9.   ResultSet rs = null;
    10.   try{
    12.       con = JDBCUtils.getConnection();
    14.       //3.获取执行者对象
    15.       stat = con.createStatement();
    17.       //4.执行sql语句，并且接收返回的结果集
    18.       String sql = "SELECT * FROM student";
    19.       rs = stat.executeQuery(sql);
    21.       //5.处理结果集
    22.       while(rs.next()) {
    23.           Integer sid = rs.getInt("sid");
    24.           String name = rs.getString("name");
    25.           Integer age = rs.getInt("age");
    26.           Date birthday = rs.getDate("birthday");
    28.           //封装Student对象
    29.           Student stu = new Student(sid,name,age,birthday);
    31.           //将student对象保存到集合中
    32.           list.add(stu);
    33.       }
    35.   } catch(Exception e) {
    36.       e.printStackTrace();
    37.   } finally {
    38.       //6.释放资源
    39.       JDBCUtils.close(con,stat,rs);
    40.   }
    41.   //将集合对象返回
    42.   return list;
    43. }

  • 条件查询

    1. /*
    2.   条件查询，根据id查询学生信息
    3. */
    4. @Override
    5. public Student findById(Integer id) {
    6.   Student stu = new Student();
    7.   Connection con = null;
    8.   Statement stat = null;
    9.   ResultSet rs = null;
    10.   try{
    12.       con = JDBCUtils.getConnection();
    14.       //3.获取执行者对象
    15.       stat = con.createStatement();
    17.       //4.执行sql语句，并且接收返回的结果集
    18.       String sql = "SELECT * FROM student WHERE sid='"+id+"'";
    19.       rs = stat.executeQuery(sql);
    21.       //5.处理结果集
    22.       while(rs.next()) {
    23.           Integer sid = rs.getInt("sid");
    24.           String name = rs.getString("name");
    25.           Integer age = rs.getInt("age");
    26.           Date birthday = rs.getDate("birthday");
    28.           //封装Student对象
    29.           stu.setSid(sid);
    30.           stu.setName(name);
    31.           stu.setAge(age);
    32.           stu.setBirthday(birthday);
    33.       }
    35.   } catch(Exception e) {
    36.       e.printStackTrace();
    37.   } finally {
    38.       //6.释放资源
    39.       JDBCUtils.close(con,stat,rs);
    40.   }
    41.   //将对象返回
    42.   return stu;
    43. }

  • 新增数据

    1. /*
    2.    添加学生信息
    3. */
    4. @Override
    5. public int insert(Student stu) {
    6.   Connection con = null;
    7.   Statement stat = null;
    8.   int result = 0;
    9.   try{
    10.       con = JDBCUtils.getConnection();
    12.       //3.获取执行者对象
    13.       stat = con.createStatement();
    15.       //4.执行sql语句，并且接收返回的结果集
    16.       Date d = stu.getBirthday();
    17.       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    18.       String birthday = sdf.format(d);
    19.       String sql = "INSERT INTO student VALUES ('"+stu.getSid()+"','"+stu.getName()+"','"+stu.getAge()+"','"+birthday+"')";
    20.       result = stat.executeUpdate(sql);
    22.   } catch(Exception e) {
    23.       e.printStackTrace();
    24.   } finally {
    25.       //6.释放资源
    26.       JDBCUtils.close(con,stat);
    27.   }
    28.   //将结果返回
    29.   return result;
    30. }

  • 修改数据

    1. /*
    2.    修改学生信息
    3. */
    4. @Override
    5. public int update(Student stu) {
    6.   Connection con = null;
    7.   Statement stat = null;
    8.   int result = 0;
    9.   try{
    10.       con = JDBCUtils.getConnection();
    12.       //3.获取执行者对象
    13.       stat = con.createStatement();
    15.       //4.执行sql语句，并且接收返回的结果集
    16.       Date d = stu.getBirthday();
    17.       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    18.       String birthday = sdf.format(d);
    19.       String sql = "UPDATE student SET sid='"+stu.getSid()+"',name='"+stu.getName()+"',age='"+stu.getAge()+"',birthday='"+birthday+"' WHERE sid='"+stu.getSid()+"'";
    20.       result = stat.executeUpdate(sql);
    22.   } catch(Exception e) {
    23.       e.printStackTrace();
    24.   } finally {
    25.       //6.释放资源
    26.       JDBCUtils.close(con,stat);
    27.   }
    28.   //将结果返回
    29.   return result;
    30. }

  • 删除数据

    1. /*
    2.  删除学生信息
    3. */
    4. @Override
    5. public int delete(Integer id) {
    6.   Connection con = null;
    7.   Statement stat = null;
    8.   int result = 0;
    9.   try{
    10.       con = JDBCUtils.getConnection();
    12.       //3.获取执行者对象
    13.       stat = con.createStatement();
    15.       //4.执行sql语句，并且接收返回的结果集
    16.       String sql = "DELETE FROM student WHERE sid='"+id+"'";
    17.       result = stat.executeUpdate(sql);
    19.   } catch(Exception e) {
    20.       e.printStackTrace();
    21.   } finally {
    22.       //6.释放资源
    23.       JDBCUtils.close(con,stat);
    24.   }
    25.   //将结果返回
    26.   return result;
    27. }

    4.3 student表的CURD整合页面

  • 用户表的数据准备 ```java — 创建用户表 CREATE TABLE USER( uid VARCHAR(50) PRIMARY KEY, — 用户id ucode VARCHAR(50), — 用户标识 loginname VARCHAR(100), — 登录用户名 PASSWORD VARCHAR(100), — 登录密码 username VARCHAR(100), — 用户名 gender VARCHAR(10), — 用户性别 birthday DATE, — 出生日期 dutydate DATE — 入职日期 );

— 添加一条测试数据 INSERT INTO user VALUES (‘11111111’, ‘zhangsan001’, ‘zhangsan’, ‘1234’, ‘张三’, ‘男’, ‘2008-10-28’, ‘2018-10-28’);

  2. - 将student表的dao层操作复制到项目中的dao层即可
  3. ```java
  4. public class StudentDaoImpl implements StudentDao {
  6.     /*
  7.         查询所有学生信息
  8.      */
  9.     @Override
  10.     public ArrayList<Student> findAll() {
  11.         Connection con = null;
  12.         Statement stat = null;
  13.         ResultSet rs = null;
  14.         ArrayList<Student> list = new ArrayList<>();
  15.         try {
  16.             //1.获取连接
  17.             con = JDBCUtils.getConnection();
  19.             //2.获取执行者对象
  20.             stat = con.createStatement();
  22.             //3.执行sql语句，并接收结果
  23.             String sql = "SELECT * FROM student";
  24.             rs = stat.executeQuery(sql);
  26.             //4.处理结果，将每条记录封装成一个Student对象。将多个Student对象保存到集合中
  27.             while(rs.next()) {
  28.                 Integer sid = rs.getInt("sid");
  29.                 String name = rs.getString("name");
  30.                 Integer age = rs.getInt("age");
  31.                 Date birthday = rs.getDate("birthday");
  33.                 Student stu = new Student(sid,name,age,birthday);
  35.                 list.add(stu);
  36.             }
  38.         } catch (SQLException e) {
  39.             e.printStackTrace();
  40.         } finally {
  41.             //5.释放资源
  42.             JDBCUtils.close(con,stat,rs);
  43.         }
  45.         return list;
  46.     }
  48.     /*
  49.         条件查询，根据id查询学生信息
  50.      */
  51.     @Override
  52.     public Student findById(Integer id) {
  53.         Connection con = null;
  54.         Statement stat = null;
  55.         ResultSet rs = null;
  56.         Student stu = new Student();
  57.         try {
  58.             //1.获取连接
  59.             con = JDBCUtils.getConnection();
  61.             //2.获取执行者对象
  62.             stat = con.createStatement();
  64.             //3.执行sql语句，并接收结果
  65.             String sql = "SELECT * FROM student WHERE sid='"+id+"'";
  66.             rs = stat.executeQuery(sql);
  68.             //4.处理结果，将记录封装成一个Student对象。
  69.             if(rs.next()) {
  70.                 Integer sid = rs.getInt("sid");
  71.                 String name = rs.getString("name");
  72.                 Integer age = rs.getInt("age");
  73.                 Date birthday = rs.getDate("birthday");
  75.                 stu.setSid(sid);
  76.                 stu.setName(name);
  77.                 stu.setAge(age);
  78.                 stu.setBirthday(birthday);
  79.             }
  81.         } catch (SQLException e) {
  82.             e.printStackTrace();
  83.         } finally {
  84.             //5.释放资源
  85.             JDBCUtils.close(con,stat,rs);
  86.         }
  88.         return stu;
  89.     }
  91.     /*
  92.         新增学生信息
  93.      */
  94.     @Override
  95.     public int insert(Student stu) {
  96.         Connection con = null;
  97.         Statement stat = null;
  98.         int result = 0;
  99.         try{
  100.             //1.获取连接
  101.             con = JDBCUtils.getConnection();
  103.             //2.获取执行者对象
  104.             stat = con.createStatement();
  106.             //3.执行sql语句，并接收结果
  107.             Date date = stu.getBirthday();
  108.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  109.             String birthday = sdf.format(date);
  110.             String sql = "INSERT INTO student VALUES (null,'"+stu.getName()+"','"+stu.getAge()+"','"+birthday+"')";
  111.             result = stat.executeUpdate(sql);
  113.         } catch (SQLException e) {
  114.             e.printStackTrace();
  115.         } finally {
  116.             //4.释放资源
  117.             JDBCUtils.close(con,stat);
  118.         }
  120.         return result;
  121.     }
  123.     /*
  124.         修改学生信息
  125.      */
  126.     @Override
  127.     public int update(Student stu) {
  128.         Connection con = null;
  129.         Statement stat = null;
  130.         int result = 0;
  131.         try{
  132.             //1.获取连接
  133.             con = JDBCUtils.getConnection();
  135.             //2.获取执行者对象
  136.             stat = con.createStatement();
  138.             //3.执行sql语句，并接收结果
  139.             Date date = stu.getBirthday();
  140.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  141.             String birthday = sdf.format(date);
  142.             String sql = "UPDATE student SET sid='"+stu.getSid()+"',name='"+stu.getName()+"',age='"+stu.getAge()+"',birthday='"+birthday+"' WHERE sid='"+stu.getSid()+"'";
  143.             result = stat.executeUpdate(sql);
  145.         } catch (SQLException e) {
  146.             e.printStackTrace();
  147.         } finally {
  148.             //4.释放资源
  149.             JDBCUtils.close(con,stat);
  150.         }
  152.         return result;
  153.     }
  155.     /*
  156.         删除学生信息
  157.      */
  158.     @Override
  159.     public int delete(Integer id) {
  160.         Connection con = null;
  161.         Statement stat = null;
  162.         int result = 0;
  163.         try{
  164.             //1.获取连接
  165.             con = JDBCUtils.getConnection();
  167.             //2.获取执行者对象
  168.             stat = con.createStatement();
  170.             //3.执行sql语句，并接收结果
  171.             String sql = "DELETE FROM student WHERE sid='"+id+"'";
  172.             result = stat.executeUpdate(sql);
  174.         } catch (SQLException e) {
  175.             e.printStackTrace();
  176.         }  finally {
  177.             //4.释放资源
  178.             JDBCUtils.close(con,stat);
  179.         }
  181.         return result;
  182.     }
  183. }

5. SQL注入攻击

5.1 SQL注入攻击的演示

  • 在登录界面，输入一个错误的用户名或密码，也可以登录成功

06.png
传入的参数是用户名和密码。
只要能根据用户名和密码查询到用户，就是成功！！
攻击：SELECT * FROM user WHERE loginname=’aaa’ AND password=’bbb’ or ‘1’=’1’
此时只要有用户aaa，不管其密码多少，都会登录成功！！

5.2 sql注入攻击的原理

  • 按照正常道理来说，我们在密码处输入的所有内容，都应该认为是密码的组成

  • 但是现在Statement对象在执行sql语句时，将一部分内容当做查询条件来执行了

    5.3 PreparedStatement的介绍

  • 预编译sql语句的执行者对象。在执行sql语句之前，将sql语句进行提前编译。明确sql语句的格式后，就不会改变了。剩余的内容都会认为是参数！参数使用?作为占位符

  • 为参数赋值的方法：setXxx(参数1,参数2);
    • 参数1：?的位置编号(编号从1开始)
    • 参数2：?的实际参数

  • 执行sql语句的方法

    • 执行insert、update、delete语句：int executeUpdate();

    • 执行select语句：ResultSet executeQuery();

      5.4 PreparedStatement

      1. /*
      2. 使用PreparedStatement的登录方法，解决注入攻击
      3. */
      4. @Override
      5. public User findByLoginNameAndPassword(String loginName, String password) {
      6. //定义必要信息
      7. Connection conn = null;
      8. PreparedStatement pstm = null;
      9. ResultSet rs = null;
      10. User user = null;
      11. try {
      12.    //1.获取连接
      13.    conn = JDBCUtils.getConnection();
      14.    //2.创建操作SQL对象
      15.    String sql = "SELECT * FROM user WHERE loginname=? AND password=?";
      16.    pstm = conn.prepareStatement(sql);
      17.    //3.设置参数
      18.    pstm.setString(1,loginName);
      19.    pstm.setString(2,password);
      20.    System.out.println(sql);
      21.    //4.执行sql语句，获取结果集
      22.    rs = pstm.executeQuery();
      23.    //5.获取结果集
      24.    if (rs.next()) {
      25.        //6.封装
      26.        user = new User();
      27.        user.setUid(rs.getString("uid"));
      28.        user.setUcode(rs.getString("ucode"));
      29.        user.setUsername(rs.getString("username"));
      30.        user.setPassword(rs.getString("password"));
      31.        user.setGender(rs.getString("gender"));
      32.        user.setDutydate(rs.getDate("dutydate"));
      33.        user.setBirthday(rs.getDate("birthday"));
      34.        user.setLoginname(rs.getString("loginname"));
      35.    }
      36.    //7.返回
      37.    return user;
      38. }catch (Exception e){
      39.    throw new RuntimeException(e);
      40. }finally {
      41.    JDBCUtils.close(conn,pstm,rs);
      42. }
      43. }

      5.5 使用PreparedStatement优化student表的CURD(作业)

      1. public class StudentDaoImpl implements StudentDao {
      3. @Override
      4. public ArrayList<Student> findAll() {
      5.    //定义必要信息
      6.    Connection conn = null;
      7.    PreparedStatement pstm = null;
      8.    ResultSet rs = null;
      9.    ArrayList<Student> students = null;
      10.    try {
      11.        //1.获取连接
      12.        conn = JDBCUtils.getConnection();
      13.        //2.获取操作对象
      14.        pstm = conn.prepareStatement("select * from student");
      15.        //3.执行sql语句，获取结果集
      16.        rs = pstm.executeQuery();
      17.        //4.遍历结果集
      18.        students = new ArrayList<Student>();
      19.        while (rs.next()) {
      20.            //5.封装
      21.            Student student = new Student();
      22.            student.setSid(rs.getInt("sid"));
      23.            student.setName(rs.getString("name"));
      24.            student.setAge(rs.getInt("age"));
      25.            student.setBirthday(rs.getDate("birthday"));
      26.            //加入到集合中
      27.            students.add(student);
      28.        }
      29.        //6.返回
      30.        return students;
      31.    }catch (Exception e){
      32.        throw new RuntimeException(e);
      33.    }finally {
      34.        JDBCUtils.close(conn,pstm,rs);
      35.    }
      36. }
      38. @Override
      39. public Student findById(Integer sid) {
      40.    //定义必要信息
      41.    Connection conn = null;
      42.    PreparedStatement pstm = null;
      43.    ResultSet rs = null;
      44.    Student student = null;
      45.    try {
      46.        //1.获取连接
      47.        conn = JDBCUtils.getConnection();
      48.        //2.获取操作对象
      49.        pstm = conn.prepareStatement("select * from student where sid = ? ");
      50.        pstm.setInt(1,sid);
      51.        //3.执行sql语句，获取结果集
      52.        rs = pstm.executeQuery();
      53.        //4.遍历结果集
      54.        if (rs.next()) {
      55.            //5.封装
      56.            student = new Student();
      57.            student.setSid(rs.getInt("sid"));
      58.            student.setName(rs.getString("name"));
      59.            student.setAge(rs.getInt("age"));
      60.            student.setBirthday(rs.getDate("birthday"));
      61.        }
      62.        //6.返回
      63.        return student;
      64.    }catch (Exception e){
      65.        throw new RuntimeException(e);
      66.    }finally {
      67.        JDBCUtils.close(conn,pstm,rs);
      68.    }
      69. }
      71. @Override
      72. public int insert(Student student) {
      73.    //定义必要信息
      74.    Connection conn = null;
      75.    PreparedStatement pstm = null;
      76.    int result = 0;
      77.    try {
      78.        //1.获取连接
      79.        conn = JDBCUtils.getConnection();
      80.        //2.获取操作对象
      81.        pstm = conn.prepareStatement("insert into student(sid,name,age,birthday)values(null,?,?,?)");
      82.        //3.设置参数
      83.        //pstm.setInt(1,null);
      84.        pstm.setString(1,student.getName());
      85.        pstm.setInt(2,student.getAge());
      86.        pstm.setDate(3,new Date(student.getBirthday().getTime()));
      87.        //4.执行sql语句
      88.        result = pstm.executeUpdate();
      89.    }catch (Exception e){
      90.        throw new RuntimeException(e);
      91.    }finally {
      92.        JDBCUtils.close(conn,pstm);
      93.    }
      94.    return result;
      95. }
      97. @Override
      98. public int update(Student student) {
      99.    //定义必要信息
      100.    Connection conn = null;
      101.    PreparedStatement pstm = null;
      102.    int result = 0;
      103.    try {
      104.        //1.获取连接
      105.        conn = JDBCUtils.getConnection();
      106.        //2.获取操作对象
      107.        pstm = conn.prepareStatement("update student set name=?,age=?,birthday=? where sid=? ");
      108.        //3.设置参数
      109.        pstm.setString(1,student.getName());
      110.        pstm.setInt(2,student.getAge());
      111.        pstm.setDate(3,new Date(student.getBirthday().getTime()));
      112.        pstm.setInt(4,student.getSid());
      113.        //4.执行sql语句
      114.        result = pstm.executeUpdate();
      115.    }catch (Exception e){
      116.        throw new RuntimeException(e);
      117.    }finally {
      118.        JDBCUtils.close(conn,pstm);
      119.    }
      120.    return result;
      121. }
      123. @Override
      124. public int delete(Integer sid) {
      125.    //定义必要信息
      126.    Connection conn = null;
      127.    PreparedStatement pstm = null;
      128.    int result = 0;
      129.    try {
      130.        //1.获取连接
      131.        conn = JDBCUtils.getConnection();
      132.        //2.获取操作对象
      133.        pstm = conn.prepareStatement("delete from student where sid=? ");
      134.        //3.设置参数
      135.        pstm.setInt(1,sid);
      136.        //4.执行sql语句
      137.        result = pstm.executeUpdate();
      138.    }catch (Exception e){
      139.        throw new RuntimeException(e);
      140.    }finally {
      141.        JDBCUtils.close(conn,pstm);
      142.    }
      143.    return result;
      144. }
      145. }

      6. JDBC事务

      6.1 JDBC如何管理事务

  • 管理事务的功能类：Connection

    • 开启事务：setAutoCommit(boolean autoCommit);参数为false则开启事务。
    • 提交事务：commit();
    • 回滚事务：rollback();

6.2 演示批量添加数据并在业务层管理事务

Service层

  • 接口

    1. /*
    2.    批量添加
    3. */
    4. void batchAdd(List<User> users);

  • 实现类

    1. /*
    2.     事务要控制在此处
    3. */
    4. @Override
    5. public void batchAdd(List<User> users) {
    6.   //获取数据库连接
    7.   Connection connection = JDBCUtils.getConnection();
    8.   try {
    9.       //开启事务
    10.       connection.setAutoCommit(false);
    11.       for (User user : users) {
    12.           //1.创建ID,并把UUID中的-替换
    13.           String uid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
    14.           //2.给user的uid赋值
    15.           user.setUid(uid);
    16.           //3.生成员工编号
    17.           user.setUcode(uid);
    19.           //模拟异常
    20.           //int n = 1 / 0;
    22.           //4.保存
    23.           userDao.save(connection,user);
    24.       }
    25.       //提交事务
    26.       connection.commit();
    27.   }catch (Exception e){
    28.       try {
    29.           //回滚事务
    30.           connection.rollback();
    31.       }catch (Exception ex){
    32.           ex.printStackTrace();
    33.       }
    34.       e.printStackTrace();
    35.   }finally {
    36.       JDBCUtils.close(connection,null,null);
    37.   }
    38. }

    dao层

  • 接口

    1. /**
    2.   支持事务的添加
    3. */
    4. void save(Connection connection,User user);

  • 实现类

    1. /*
    2.      支持事务的添加
    3. */
    4. @Override
    5. public void save(Connection connection, User user) {
    6.   //定义必要信息
    7.   PreparedStatement pstm = null;
    8.   try {
    9.       //1.获取连接
    10.       connection = JDBCUtils.getConnection();
    11.       //2.获取操作对象
    12.       pstm = connection.prepareStatement("insert into user(uid,ucode,loginname,password,username,gender,birthday,dutydate)values(?,?,?,?,?,?,?,?)");
    13.       //3.设置参数
    14.       pstm.setString(1,user.getUid());
    15.       pstm.setString(2,user.getUcode());
    16.       pstm.setString(3,user.getLoginname());
    17.       pstm.setString(4,user.getPassword());
    18.       pstm.setString(5,user.getUsername());
    19.       pstm.setString(6,user.getGender());
    20.       pstm.setDate(7,new Date(user.getBirthday().getTime()));
    21.       pstm.setDate(8,new Date(user.getDutydate().getTime()));
    22.       //4.执行sql语句，获取结果集
    23.       pstm.executeUpdate();
    24.   }catch (Exception e){
    25.       throw new RuntimeException(e);
    26.   }finally {
    27.       JDBCUtils.close(null,pstm,null);
    28.   }
    29. }