java JDBC 增删改查及封装

亦凉 2022-10-05 14:46 273阅读 0赞

1、插入数据

  1. package com;
  2. import java.sql.*;
  3. public class lxc {
  4.     public static void main(String[] args) {
  5.         //  /useUnicode表示允许使用自定义的Unicode, //characterEncoding是给定自定义的Unicode是什么，解决乱码或问号的问题
  6.         String url = "jdbc:mysql://127.0.0.1:3306/java_pro?useUnicode=true&characterEncoding=utf8";
  7.         String user = "root";
  8.         String password = "lvxingchen@123";
  10.         Connection conne = null;
  11.         Statement sta = null;
  12.         try {
  13.             // 注册驱动
  14.             Class.forName("com.mysql.jdbc.Driver");
  15.             // 获取连接 - 连接mysql数据库
  16.             try {
  17.                 conne = DriverManager.getConnection(url, user, password); // 获取连接对象
  18.                 sta = conne.createStatement();// createStatement 专门执行sql语句的
  19.                 String sql = "insert into user(name, age, address) values('吕星辰', 20, '烟台市')";
  20.                 // 专门执行DML语句的，返回的是影响数据库的数据条数
  21.                 int count = sta.executeUpdate(sql);
  22.                 System.out.println(count == 1 ? "插入成功" : "插入失败");
  23.             } catch (SQLException throwables) {
  24.                 throwables.printStackTrace();
  25.             } finally {
  26.                 // 在finally中释放资源，并且按顺序依次关闭
  27.                 try {
  28.                     if(sta != null) {
  29.                         sta.close();
  30.                     }
  31.                 } catch (SQLException throwables) {
  32.                     throwables.printStackTrace();
  33.                 }
  34.                 try {
  35.                     if(conne != null) {
  36.                         conne.close();
  37.                     }
  38.                 } catch (SQLException throwables) {
  39.                     throwables.printStackTrace();
  40.                 }
  41.             }
  42.         } catch (ClassNotFoundException e) {
  43.             e.printStackTrace();
  44.         }
  45.     }
  46. }

2、抽离全局配置

上边我们可以把全局的变量抽离出来，放在properties文件中：

项目目录
db.properties与com同级

2021061008563633.png

db.properties

  1. url=jdbc:mysql://127.0.0.1:3306/java_pro?useUnicode=true&characterEncoding=utf8
  2. user=root
  3. password=lvxingchen@123
  4. driver=com.mysql.jdbc.Driver

在项目文件中引入通过ResourceBundle加载配置文件

  1. package com;
  2. import java.sql.*;
  3. import java.util.ResourceBundle;
  5. public class lxc {
  6.     public static void main(String[] args) {
  7.         ResourceBundle resourceBundle = ResourceBundle.getBundle("db");
  8.         String driver = resourceBundle.getString("driver");
  9.         String url = resourceBundle.getString("url");
  10.         String user = resourceBundle.getString("user");
  11.         String password = resourceBundle.getString("password");
  13.         Connection conne = null;
  14.         Statement sta = null;
  15.         try {
  16.             Class.forName(driver);
  17.             try {
  18.                 conne = DriverManager.getConnection(url, user, password); // 获取连接对象
  19.                 sta = conne.createStatement();// createStatement 专门执行sql语句的
  20.                 String sql = "insert into user(name, age, address) values('吕星辰', 20, '烟台市')";
  21.                 int count = sta.executeUpdate(sql);
  22.                 System.out.println(count == 1 ? "插入成功" : "插入失败");
  23.             } catch (SQLException throwables) {
  24.                 throwables.printStackTrace();
  25.             } finally {
  26.                 try {
  27.                     sta.close();
  28.                 } catch (SQLException throwables) {
  29.                     throwables.printStackTrace();
  30.                 }
  31.                 try {
  32.                     conne.close();
  33.                 } catch (SQLException throwables) {
  34.                     throwables.printStackTrace();
  35.                 }
  36.             }
  37.         } catch (ClassNotFoundException e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41. }

3、java连接数据库封装（以mysql为例）

db.properties 配置文件

  1. // db.properties
  2. url=jdbc:mysql://127.0.0.1:3306/java_pro?useUnicode=true&characterEncoding=utf8
  3. user=root
  4. password=lvxingchen@123
  5. driver=com.mysql.jdbc.Driver

封装JDBCutil.java文件，下边只是简单的封装，查询结果集直接拼接字符串打印的：

  1. package com;
  3. import java.sql.*;
  4. import java.util.ResourceBundle;
  7. /**
  8.  * @对外暴露的方法:
  9.  * （1）public void login(String name,String password) 账号密码登录
  10.  * （2）public void getAll() 获取数据
  11.  * （3）public void insert(String name,int age,String address,String password) 插入数据
  12.  */
  13. public class JDBCutil {
  14.     private final static String url;
  15.     private final static String user;
  16.     private final static String password;
  17.     public Connection driverManager = null; // 获取数据库连接对象
  18.     private static JDBCutil jdbc;
  20.     // 静态代码块注册驱动 - 在类加载的时候执行一次。
  21.     static {
  22.         ResourceBundle resourceBundle = ResourceBundle.getBundle("db");
  23.         String driver = resourceBundle.getString("driver");
  24.         url = resourceBundle.getString("url");
  25.         user = resourceBundle.getString("user");
  26.         password = resourceBundle.getString("password");
  27.         try {
  28.             Class.forName(driver); // 注册驱动
  29.             jdbc = new JDBCutil();
  30.             // jdbc.getConnection(); // 连接数据库，及获取数据库对象
  31.         } catch (ClassNotFoundException e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  35.     // 子类会重写父类的main方法，所以父类main方法不会执行！
  36.     // public static void main(String[] args) {
  37.     //     System.out.println("执行了+++++++++++++++++++++++");
  38.     //     new com.B.JDBCutil().getConnection(); // 连接数据库
  39.     // }
  40.     // 获取数据库连接对象
  41.     private void getConnection() {
  42.         try {
  43.             jdbc.driverManager = DriverManager.getConnection(url, user, password);
  44.         } catch (SQLException throwables) {
  45.             throwables.printStackTrace();
  46.             System.out.println("连接失败");
  47.         }
  48.         System.out.println("****************************连接成功************************");
  49.     }
  50.     // 账号密码登录，成功返回true，失败返回false
  51.     public Boolean getOne(String name, String password) {
  52.         // Statement statement = null;
  53.         PreparedStatement statement = null; // PreparedStatement：预编译的数据库操作对象，可防止SQL注入
  54.         ResultSet resultSet = null;
  55.         boolean resStatus = false;
  56.         try {
  57.             System.out.println("jdbc.driverManager:"+jdbc.driverManager);
  58.             // 这地方在加一层判断，因为增删改查完之后，会关闭数据库连接
  59.             if(jdbc.driverManager == null) {
  60.                 jdbc.getConnection();
  61.             }
  62.             /**
  63.              * 使用 Statement 
  64.              * Statement statement = null; // SQL注入
  65.              * statement = jdbc.driverManager.createStatement(String sql)
  66.              * resultSet = statement.executeQuery();
  67.              */
  69.             String sq = "select * from java_pro where name = ? and password = ?"; // 提前定义好SQL语句的框架 ?：表示占位符，单引号不能使用单引号括起来！
  70.             // 预编译上边的SQL语句
  71.             statement = jdbc.driverManager.prepareStatement(sq);
  72.             // 给占位符 ? 传值
  73.             // 第一个问号下标为1，第二个问号下标是2，以此类推
  74.             statement.setString(1, name);
  75.             statement.setString(2, password);
  76.             // 专门执行查询语句 executeQuery()
  77.             resultSet = statement.executeQuery(); // 返回的是一个查询结果集 - 结果集也需要关闭
  78.             // 遍历查询结果集：
  79.             // resultSet.next() 方法 - 让光标往下移动一行，如果走到的的这一行有数据，则返回true，
  80.             // 则把这一行数据分贝取出来即可；继续往下移动下一行；依次循环，如果没数据next() 方法会返回false，停止循环
  81.             boolean status = resultSet.next();
  82.             int count = 0;
  83.             System.out.println("***********************************************************");
  84.             if(status) {
  85.                 resStatus = true;
  86.             }
  87.             System.out.println("***********************一共"+count+"条数据！************************");
  88.         } catch (SQLException throwables) {
  89.             throwables.printStackTrace();
  90.         }finally {
  91.             if(resultSet != null) {
  92.                 try {
  93.                     resultSet.close(); // 关闭结果集
  94.                 } catch (SQLException throwables) {
  95.                     throwables.printStackTrace();
  96.                 }
  97.             }
  98.             if(statement != null) {
  99.                 try {
  100.                     statement.close();
  101.                 } catch (SQLException throwables) {
  102.                     throwables.printStackTrace();
  103.                 }
  104.             }
  105.             // 关闭数据库连接
  106.             jdbc.close();
  107.         }
  108.         return resStatus;
  109.     }
  110.     // 查询
  111.     public void getAll() {
  112.         PreparedStatement statement = null;
  113.         ResultSet resultSet = null;
  114.         try {
  115.             System.out.println("jdbc.driverManager:"+jdbc.driverManager);
  116.             // 这地方在加一层判断，因为增删改查完之后，会关闭数据库连接
  117.             if(jdbc.driverManager == null) {
  118.                 jdbc.getConnection();
  119.             }
  120.             String sql = "select * from java_pro";
  121.             // 预编译sql语句，防止SQL注入
  122.             statement = jdbc.driverManager.prepareStatement(sql);
  123.             // 专门执行查询语句 executeQuery()
  124.             resultSet = statement.executeQuery(); // 返回的是一个查询结果集 - 结果集也需要关闭
  125.             // 遍历查询结果集：
  126.             // resultSet.next() 方法 - 让光标往下移动一行，如果走到的的这一行有数据，则返回true，
  127.             // 则把这一行数据分贝取出来即可；继续往下移动下一行；依次循环，如果没数据next() 方法会返回false，停止循环
  128.             boolean status = resultSet.next();
  129.             int count = 0;
  130.             System.out.println("***********************************************************");
  131.             while(status) {
  132.                 count ++;
  133.                 // 取数据
  134.                 // .getString() 不管数据库里边的数据类型是什么，都以字符串形式返回！getTnt() 取出的是数字类型，别的类型，请查看文档 ··· ···
  135.                 // .getString(1): 通过下标取数据(注意下边从1开始);
  136.                 // .getString("name"): 通过列字段取数据;
  137.                 String name = resultSet.getString("name");
  138.                 int age = resultSet.getInt("age");
  139.                 String address = resultSet.getString("address");
  140.                 System.out.println("查询出的数据结果为："+name+"-"+age+"-"+address);
  141.                 status = resultSet.next();
  142.             }
  143.             System.out.println("***********************一共"+count+"条数据！************************");
  144.         } catch (SQLException throwables) {
  145.             throwables.printStackTrace();
  146.         }finally {
  147.             if(resultSet != null) {
  148.                 try {
  149.                     resultSet.close(); // 关闭结果集
  150.                 } catch (SQLException throwables) {
  151.                     throwables.printStackTrace();
  152.                 }
  153.             }
  154.             if(statement != null) {
  155.                 try {
  156.                     statement.close();
  157.                 } catch (SQLException throwables) {
  158.                     throwables.printStackTrace();
  159.                 }
  160.             }
  161.             // 关闭数据库连接
  162.             jdbc.close();
  163.         }
  164.     }
  165.     // 插入sql语句执行，暂时无返回数据
  166.     public void insert(String name,int age,String address,String password) {
  167.         PreparedStatement statement = null;
  168.         try {
  169.             // 这地方在加一层判断，因为增删改查完之后，会关闭数据库连接
  170.             if(jdbc.driverManager == null) {
  171.                 jdbc.getConnection();
  172.             }
  173.             String sql = "insert into java_pro (name, age, address, password) values (?, ?, ?, ?)";
  174.             // 预编译sql语句，当值sql注入
  175.             statement = jdbc.driverManager.prepareStatement(sql);
  176.             // 把?替换为用户传过来的参数
  177.             statement.setString(1, name);
  178.             statement.setInt(2, age);
  179.             statement.setString(3, address);
  180.             statement.setString(4, password);
  181.             // 执行sql语句
  182.             int count = statement.executeUpdate();
  183.             System.out.println(count == 1 ? "成功" : "失败");
  184.         } catch (SQLException throwables) {
  185.             throwables.printStackTrace();
  186.         }finally {
  187.             if(statement != null) {
  188.                 try {
  189.                     statement.close();
  190.                 } catch (SQLException throwables) {
  191.                     throwables.printStackTrace();
  192.                 }
  193.             }
  194.             // 关闭数据库连接
  195.             jdbc.close();
  196.         }
  197.     }
  198.     // 关闭数据库连接
  199.     private void close() {
  200.         try {
  201.             if(jdbc.driverManager != null) {
  202.                 jdbc.driverManager.close();
  203.                 jdbc.driverManager = null;
  204.             }
  205.         } catch (SQLException throwables) {
  206.             throwables.printStackTrace();
  207.         }
  208.     }
  209. }

补充：
解决SQL注入的关键问题

用户提供的信息中，即使含有sql语句的关键字，但是这些关键字并没有参与编译，不起作用。
Statment和PreparedStatment对比？

Statment：存在sql注入的问题，编译一次执行一次。
PreparedStatment：解决了sql注入的问题，执行效率较高，编译一次执行N次，它会在编译阶段做类型检查。

发表评论

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

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

相关阅读

    相关 JDBC增删改查案例讲解

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

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

    相关 JDBC进行增删查改

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

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