JDBC增删改查案例讲解

快来打我* 2024-03-31 11:23 187阅读 0赞

JDBC增删改查案例讲解

简介：这是一个网上非常常见的，JDBC的练习题，系统大家通过本文的讲解，熟悉JDBC的增删改查。

推荐学习路线：JDBC数据库的连接->Connection（数据库连接对象）->Driud数据库连接池的使用->ResultSet->通过PreparedStatement预防SQL注入->JDBC增删改查案例讲解 大家跟着敲完基本就可以JDBC基础毕业了。

题目要求为：
完成商品品牌数据的增删改查操作，把每个操作封装成为对应函数。

  • 查询：查询所有数据
  • 添加：添加品牌
  • 修改：根据id修改
  • 删除：根据id删除

环境准备

  • 数据库表 tb_brand
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

数据库建表语句：

  1. -- 删除tb_brand表
  2. drop table if exists tb_brand;
  3. -- 创建tb_brand表
  4. create table tb_brand (
  5.     -- id 主键
  6.     id int primary key auto_increment,
  7.     -- 品牌名称
  8.     brand_name varchar(20),
  9.     -- 企业名称
  10.     company_name varchar(20),
  11.     -- 排序字段
  12.     ordered int,
  13.     -- 描述信息
  14.     description varchar(100),
  15.     -- 状态：0：禁用  1：启用
  16.     status int
  17. );
  18. -- 添加数据
  19. insert into tb_brand (brand_name, company_name, ordered, description, status)
  20. values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
  21.        ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
  22.        ('小米', '小米科技有限公司', 50, 'are you ok', 1);

  • 创建工具包pojo
    在这里插入图片描述
    在这里插入图片描述
    Brand类

    package com.study.pojo;

    /**

    • 品牌类
    • alt + 鼠标左键：整列编辑

    • 在实体类中，基本数据类型建议使用其对应的包装类型
      */
      public class Brand {

      // id 主键
      private Integer id;
      // 品牌名称
      private String brandName;
      // 企业名称
      private String companyName;
      // 排序字段
      private Integer ordered;
      // 描述信息
      private String description;
      // 状态：0：禁用 1：启用
      private Integer status;

      public Integer getId() {

      1.  return id;

      }

      public void setId(Integer id) {

      1.  this.id = id;

      }

      public String getBrandName() {

      1.  return brandName;

      }

      public void setBrandName(String brandName) {

      1.  this.brandName = brandName;

      }

      public String getCompanyName() {

      1.  return companyName;

      }

      public void setCompanyName(String companyName) {

      1.  this.companyName = companyName;

      }

      public Integer getOrdered() {

      1.  return ordered;

      }

      public void setOrdered(Integer ordered) {

      1.  this.ordered = ordered;

      }

      public String getDescription() {

      1.  return description;

      }

      public void setDescription(String description) {

      1.  this.description = description;

      }

      public Integer getStatus() {

      1.  return status;

      }

      public void setStatus(Integer status) {

      1.  this.status = status;

      }

      @Override
      public String toString() {

      1.  return "Brand{" +
      2.          "id=" + id +
      3.          ", brandName='" + brandName + '\'' +
      4.          ", companyName='" + companyName + '\'' +
      5.          ", ordered=" + ordered +
      6.          ", description='" + description + '\'' +
      7.          ", status=" + status +
      8.          '}';

      }
      }

代码讲解

  1. package com.study.jdbc;
  4. import com.alibaba.druid.pool.DruidDataSourceFactory;
  5. import com.study.pojo.Brand;
  7. import javax.sql.DataSource;
  8. import java.io.FileInputStream;
  9. import java.sql.*;
  10. import java.util.ArrayList;
  11. import java.util.List;
  12. import java.util.Properties;
  15. public class JDBCDemo {
  17.     /**
  18.      * 查询所有
  19.      * 1. SQL：select * from tb_brand;
  20.      * 2. 参数：不需要
  21.      * 3. 结果：List<Brand>
  22.      */
  23.     public static void testSelectAll(Connection conn) throws Exception {
  25.         //2. 定义SQL
  26.         String sql = "select * from tb_brand;";
  27.         //3. 获取pstmt对象
  28.         PreparedStatement pstmt = conn.prepareStatement(sql);
  29.         //4. 设置参数
  30.         //5. 执行SQL
  31.         ResultSet rs = pstmt.executeQuery();
  32.         //6. 处理结果 List<Brand> 封装Brand对象，装载List集合
  33.         Brand brand = null;
  34.         List<Brand> brands = new ArrayList<>();
  35.         while (rs.next()){
  37.             //获取数据
  38.             int id = rs.getInt("id");
  39.             String brandName = rs.getString("brand_name");
  40.             String companyName = rs.getString("company_name");
  41.             int ordered = rs.getInt("ordered");
  42.             String description = rs.getString("description");
  43.             int status = rs.getInt("status");
  44.             //封装Brand对象
  45.             brand = new Brand();
  46.             brand.setId(id);
  47.             brand.setBrandName(brandName);
  48.             brand.setCompanyName(companyName);
  49.             brand.setOrdered(ordered);
  50.             brand.setDescription(description);
  51.             brand.setStatus(status);
  53.             //装载集合
  54.             brands.add(brand);
  55.         }
  56.         System.out.println(brands);
  57.         //7. 释放资源
  58.         rs.close();
  59.         pstmt.close();
  60.     }
  62.     /**
  63.      * 添加
  64.      * 1. SQL：insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
  65.      * 2. 参数：需要，除了id之外的所有参数信息
  66.      * 3. 结果：boolean
  67.      */
  68.     public static void testAdd(Connection conn) throws Exception {
  70.         // 接收页面提交的参数
  71.         String brandName = "香飘飘";
  72.         String companyName = "香飘飘";
  73.         int ordered = 1;
  74.         String description = "绕地球一圈";
  75.         int status = 1;
  78.         //2. 定义SQL
  79.         String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);";
  80.         //3. 获取pstmt对象
  81.         PreparedStatement pstmt = conn.prepareStatement(sql);
  82.         //4. 设置参数
  83.         pstmt.setString(1,brandName);
  84.         pstmt.setString(2,companyName);
  85.         pstmt.setInt(3,ordered);
  86.         pstmt.setString(4,description);
  87.         pstmt.setInt(5,status);
  89.         //5. 执行SQL
  90.         int count = pstmt.executeUpdate(); // 影响的行数
  91.         //6. 处理结果
  92.         System.out.println(count > 0);
  94.         //7. 释放资源
  95.         pstmt.close();
  96.     }
  98.     /**
  99.      * 修改
  100.      * 1. SQL：
  102.      update tb_brand
  103.      set brand_name  = ?,
  104.      company_name= ?,
  105.      ordered     = ?,
  106.      description = ?,
  107.      status      = ?
  108.      where id = ?
  110.      * 2. 参数：需要，所有数据
  111.      * 3. 结果：boolean
  112.      */
  114.     public static void testUpdate(Connection conn) throws Exception {
  116.         // 接收页面提交的参数
  117.         String brandName = "香飘飘";
  118.         String companyName = "香飘飘";
  119.         int ordered = 1000;
  120.         String description = "绕地球三圈";
  121.         int status = 1;
  122.         int id = 4;
  124.         //2. 定义SQL
  125.         String sql = " update tb_brand\n" +
  126.                 "         set brand_name  = ?,\n" +
  127.                 "         company_name= ?,\n" +
  128.                 "         ordered     = ?,\n" +
  129.                 "         description = ?,\n" +
  130.                 "         status      = ?\n" +
  131.                 "     where id = ?";
  133.         //3. 获取pstmt对象
  134.         PreparedStatement pstmt = conn.prepareStatement(sql);
  136.         //4. 设置参数
  137.         pstmt.setString(1,brandName);
  138.         pstmt.setString(2,companyName);
  139.         pstmt.setInt(3,ordered);
  140.         pstmt.setString(4,description);
  141.         pstmt.setInt(5,status);
  142.         pstmt.setInt(6,id);
  144.         //5. 执行SQL
  145.         int count = pstmt.executeUpdate(); // 影响的行数
  146.         //6. 处理结果
  147.         System.out.println(count > 0);
  149.         //7. 释放资源
  150.         pstmt.close();
  151.     }
  153.     /**
  154.      * 删除
  155.      * 1. SQL：
  156.      delete from tb_brand where id = ?
  157.      * 2. 参数：需要，id
  158.      * 3. 结果：boolean
  159.      */
  161.     public static void testDeleteById(Connection conn) throws Exception {
  163.         // 接收页面提交的参数
  164.         int id = 4;
  166.         //2. 定义SQL
  167.         String sql = " delete from tb_brand where id = ?";
  168.         //3. 获取pstmt对象
  169.         PreparedStatement pstmt = conn.prepareStatement(sql);
  170.         //4. 设置参数
  171.         pstmt.setInt(1,id);
  172.         //5. 执行SQL
  173.         int count = pstmt.executeUpdate(); // 影响的行数
  174.         //6. 处理结果
  175.         System.out.println(count > 0);
  177.         //7. 释放资源
  178.         pstmt.close();
  179.     }
  181.     public static void main(String[] args) throws Exception {
  183.         Properties prop = new Properties();
  184.         prop.load(new FileInputStream("src/com/study/druid.properties"));
  185.         //4. 获取连接池对象
  186.         DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  188.         //5. 获取数据库连接 Connection
  189.         Connection conn = dataSource.getConnection();
  191.         // 测试查询全部
  192.         testSelectAll(conn);
  194.         // 测试添加
  195.         testAdd(conn);
  197.         // 测试更新
  198.         testUpdate(conn);
  200.         // 测试删除
  201.         testDeleteById(conn);
  203.         conn.close();  // 统一删除
  204.     }
  205. }

运行结果：
在这里插入图片描述

分模块演示

查询所有

  1. public void testSelectAll() throws Exception {
  3.     //1. 获取Connection
  4.     //3. 加载配置文件
  5.     Properties prop = new Properties();
  6.     prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
  7.     //4. 获取连接池对象
  8.     DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  10.     //5. 获取数据库连接 Connection
  11.     Connection conn = dataSource.getConnection();
  12.     //2. 定义SQL
  13.     String sql = "select * from tb_brand;";
  14.     //3. 获取pstmt对象
  15.     PreparedStatement pstmt = conn.prepareStatement(sql);
  16.     //4. 设置参数
  17.     //5. 执行SQL
  18.     ResultSet rs = pstmt.executeQuery();
  19.     //6. 处理结果 List<Brand> 封装Brand对象，装载List集合
  20.     Brand brand = null;
  21.     List<Brand> brands = new ArrayList<>();
  22.     while (rs.next()){
  24.         //获取数据
  25.         int id = rs.getInt("id");
  26.         String brandName = rs.getString("brand_name");
  27.         String companyName = rs.getString("company_name");
  28.         int ordered = rs.getInt("ordered");
  29.         String description = rs.getString("description");
  30.         int status = rs.getInt("status");
  31.         //封装Brand对象
  32.         brand = new Brand();
  33.         brand.setId(id);
  34.         brand.setBrandName(brandName);
  35.         brand.setCompanyName(companyName);
  36.         brand.setOrdered(ordered);
  37.         brand.setDescription(description);
  38.         brand.setStatus(status);
  40.         //装载集合
  41.         brands.add(brand);
  42.     }
  43.     System.out.println(brands);
  44.     //7. 释放资源
  45.     rs.close();
  46.     pstmt.close();
  47.     conn.close();
  48. }

添加数据

  1. /**
  2.   * 添加
  3.   * 1. SQL：insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
  4.   * 2. 参数：需要，除了id之外的所有参数信息
  5.   * 3. 结果：boolean
  6.   */
  7. public void testAdd() throws Exception {
  9.     // 接收页面提交的参数
  10.     String brandName = "香飘飘";
  11.     String companyName = "香飘飘";
  12.     int ordered = 1;
  13.     String description = "绕地球一圈";
  14.     int status = 1;
  16.     //1. 获取Connection
  17.     //3. 加载配置文件
  18.     Properties prop = new Properties();
  19.     prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
  20.     //4. 获取连接池对象
  21.     DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  22.     //5. 获取数据库连接 Connection
  23.     Connection conn = dataSource.getConnection();
  24.     //2. 定义SQL
  25.     String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);";
  26.     //3. 获取pstmt对象
  27.     PreparedStatement pstmt = conn.prepareStatement(sql);
  28.     //4. 设置参数
  29.     pstmt.setString(1,brandName);
  30.     pstmt.setString(2,companyName);
  31.     pstmt.setInt(3,ordered);
  32.     pstmt.setString(4,description);
  33.     pstmt.setInt(5,status);
  35.     //5. 执行SQL
  36.     int count = pstmt.executeUpdate(); // 影响的行数
  37.     //6. 处理结果
  38.     System.out.println(count > 0);
  40.     //7. 释放资源
  41.     pstmt.close();
  42.     conn.close();
  43. }

修改数据

  1. /**
  2.   * 修改
  3.   * 1. SQL：
  5.      update tb_brand
  6.          set brand_name  = ?,
  7.          company_name= ?,
  8.          ordered     = ?,
  9.          description = ?,
  10.          status      = ?
  11.      where id = ?
  13.    * 2. 参数：需要，所有数据
  14.    * 3. 结果：boolean
  15.    */
  17. public void testUpdate() throws Exception {
  19.     // 接收页面提交的参数
  20.     String brandName = "香飘飘";
  21.     String companyName = "香飘飘";
  22.     int ordered = 1000;
  23.     String description = "绕地球三圈";
  24.     int status = 1;
  25.     int id = 4;
  27.     //1. 获取Connection
  28.     //3. 加载配置文件
  29.     Properties prop = new Properties();
  30.     prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
  31.     //4. 获取连接池对象
  32.     DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  33.     //5. 获取数据库连接 Connection
  34.     Connection conn = dataSource.getConnection();
  35.     //2. 定义SQL
  36.     String sql = " update tb_brand\n" +
  37.         "         set brand_name  = ?,\n" +
  38.         "         company_name= ?,\n" +
  39.         "         ordered     = ?,\n" +
  40.         "         description = ?,\n" +
  41.         "         status      = ?\n" +
  42.         "     where id = ?";
  44.     //3. 获取pstmt对象
  45.     PreparedStatement pstmt = conn.prepareStatement(sql);
  47.     //4. 设置参数
  48.     pstmt.setString(1,brandName);
  49.     pstmt.setString(2,companyName);
  50.     pstmt.setInt(3,ordered);
  51.     pstmt.setString(4,description);
  52.     pstmt.setInt(5,status);
  53.     pstmt.setInt(6,id);
  55.     //5. 执行SQL
  56.     int count = pstmt.executeUpdate(); // 影响的行数
  57.     //6. 处理结果
  58.     System.out.println(count > 0);
  60.     //7. 释放资源
  61.     pstmt.close();
  62.     conn.close();
  63. }

删除数据

  1. /**
  2.   * 删除
  3.   * 1. SQL：
  4.             delete from tb_brand where id = ?
  5.   * 2. 参数：需要，id
  6.   * 3. 结果：boolean
  7.   */
  8. public void testDeleteById() throws Exception {
  10.     // 接收页面提交的参数
  11.     int id = 4;
  12.     //1. 获取Connection
  13.     //3. 加载配置文件
  14.     Properties prop = new Properties();
  15.     prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
  16.     //4. 获取连接池对象
  17.     DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  18.     //5. 获取数据库连接 Connection
  19.     Connection conn = dataSource.getConnection();
  20.     //2. 定义SQL
  21.     String sql = " delete from tb_brand where id = ?";
  22.     //3. 获取pstmt对象
  23.     PreparedStatement pstmt = conn.prepareStatement(sql);
  24.     //4. 设置参数
  25.     pstmt.setInt(1,id);
  26.     //5. 执行SQL
  27.     int count = pstmt.executeUpdate(); // 影响的行数
  28.     //6. 处理结果
  29.     System.out.println(count > 0);
  31.     //7. 释放资源
  32.     pstmt.close();
  33.     conn.close();
  34. }

发表评论

表情：
评论列表 （有 0 条评论，187人围观）

还没有评论，来说两句吧...

相关阅读

    相关 JDBC增删改查案例讲解

    JDBC增删改查案例讲解 简介：这是一个网上非常常见的，JDBC的练习题，系统大家通过本文的讲解，熟悉JDBC的增删改查。 推荐学习路线：[JDBC数据库的连接][JD

    快来打我*快来打我*/ 0 赞/ 188 阅读

    相关 JDBC进行增删查改

    JDBC进行增删改查 本篇博客较为基础，只作学习记录之用。 本篇分为： 下载JDBC的jar包 导入JDBC的jar包 封装数据库连接和关闭

    冷不防冷不防/ 0 赞/ 429 阅读