一、封装一个类

在一个utils工具包，在下面写一个JdbcUtil工具类

  1. package com.qfedu.utils;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.sql.*;
  7. import java.util.Properties;
  9. /**
  10.  * @author wodexinhuai
  11.  * @create 2022-04-27-9:35
  12.  */
  13. public class JdbcUtil {
  14.     private static String url = null;
  15.     private static String user = null;
  16.     private static String password = null;
  17.     static{
  18.         Properties properties = new Properties();
  19.         try {
  20.             properties.load(new FileInputStream("E:\\idea_workspace\\zhuzhiwei\\day39\\src\\db.properties"));
  21.             String driver = properties.getProperty("Driver");
  22.             url = properties.getProperty("url");
  23.             user = properties.getProperty("user");
  24.             password = properties.getProperty("password");
  25.             Class.forName(driver);
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         }
  29.     }
  31.     public static Connection getConnection(){
  32.         Connection connection = null;
  33.         try {
  34.             connection = DriverManager.getConnection(url, user, password);
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         }
  38.         return connection;
  39.     }
  40.     public static void close(Connection connection){
  41.         try {
  42.             connection.close();
  43.         } catch (SQLException e) {
  44.             e.printStackTrace();
  45.         }
  46.     }
  47.     public static void close(Connection connection, Statement statement){
  48.         try {
  49.             connection.close();
  50.             statement.close();
  51.         } catch (SQLException e) {
  52.             e.printStackTrace();
  53.         }
  54.     }
  55.     public static void close(Connection connection,Statement statement, ResultSet resultSet){
  56.         try {
  57.             connection.close();
  58.             statement.close();
  59.             resultSet.close();
  60.         } catch (SQLException e) {
  61.             e.printStackTrace();
  62.         }
  64.     }
  65. }

在src写新建一个.properti的配置文件

  1. Driver=com.mysql.jdbc.Driver
  2. url=jdbc:mysql://localhost:3306/java2204?useSSL=false
  3. user=root
  4. password=123456

再次增删改查时，可以直接调用封装好的类，让代码更加简洁

  1. package com.qfedu.test;
  3. import com.qfedu.utils.JdbcUtil;
  4. import org.junit.jupiter.api.Test;
  6. import java.sql.Connection;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.sql.Statement;
  11. /**
  12.  * @author wodexinhuai
  13.  * @create 2022-04-27-9:34
  14.  */
  15. public class Demo1 {
  16.     public static void main(String[] args) throws SQLException {
  17. //    @Test
  18. //    public void testAdd() throws SQLException {
  19.         Connection connection = JdbcUtil.getConnection();
  20.         Statement statement = connection.createStatement();
  21.         String sql = "insert into work(name,age,info) values('z志伟',24,'哈哈哈哈')";
  22.         int i = statement.executeUpdate(sql);
  23.         System.out.println(i);
  24.         JdbcUtil.close(connection,statement);
  25.     }
  26.     @Test
  27.     public void testDelete() throws SQLException {
  28.         Connection connection = JdbcUtil.getConnection();
  29.         Statement statement = connection.createStatement();
  30.         String sql = "delete from work where id = 4";
  31.         int i = statement.executeUpdate(sql);
  32.         JdbcUtil.close(connection,statement);
  33.     }
  34.     @Test
  35.     public void testCelect() throws SQLException {
  36.         Connection connection = JdbcUtil.getConnection();
  37.         Statement statement = connection.createStatement();
  38.         String sql = "select * from work";
  39.         ResultSet resultSet = statement.executeQuery(sql);
  40.         while(resultSet.next()){
  41.             int id = resultSet.getInt("id");
  42.             System.out.println(id);
  43.         }
  44.         JdbcUtil.close(connection,statement,resultSet);
  45.     }
  46. }

二、预处理的搬运工对象

以后不用Statement，

参数化的SQL语句：insert into work(name,age,info) values(?,?,?)

静态的SQL语句：insert into work(name,age,info) values(“朱”,10,“啊啊”)

  1. PreparedStatement preparedStatement = connection.prepareStatement(参数化的SQL语句);

2.1增

  1. package com.qfedu.test2yuchuli;
  3. import com.qfedu.utils.JdbcUtil;
  5. import java.sql.Connection;
  6. import java.sql.PreparedStatement;
  7. import java.sql.SQLException;
  8. import java.sql.Statement;
  10. /**
  11.  * @author wodexinhuai
  12.  * @create 2022-04-27-10:53
  13.  * 预处理搬运工
  14.  */
  15. public class Demo1 {
  16.     public static void main(String[] args) throws SQLException {
  17.         //1.获取connection对象
  18.         Connection connection = JdbcUtil.getConnection();
  19.         //2.准备一个参数化的sql语句   ?只是占位
  20.         String sql = "insert into work(name,age,info) values (?,?,?)";
  21.         //3.使用connection对象获取预处理搬运工对象
  22.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  23.         //4.对参数化的sql语句的？进行赋值
  24.         preparedStatement.setObject(1,"朱");
  25.         preparedStatement.setObject(2,99);
  26.         preparedStatement.setObject(3,"信息");
  27.         //5.执行sql语句
  28.         int i = preparedStatement.executeUpdate();
  29.         System.out.println(i);
  30.         //6.关闭资源 preparedStatement是statement的子类
  31.         JdbcUtil.close(connection, preparedStatement);
  33.     }
  34. }

2.2模糊查询

  1. package com.qfedu.test2yuchuli;
  3. import com.qfedu.utils.JdbcUtil;
  5. import java.sql.Connection;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.util.Collection;
  11. /**
  12.  * @author wodexinhuai
  13.  * @create 2022-04-27-11:42
  14.  */
  15. public class Demo5like {
  16.     public static void main(String[] args) throws SQLException {
  17.         Connection connection = JdbcUtil.getConnection();
  18.         String sql = "select * from work where name like ?";
  19.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  20.         preparedStatement.setObject(1,"%博%");
  21.         ResultSet resultSet = preparedStatement.executeQuery();
  22.         while (resultSet.next()){
  23.             int id = resultSet.getInt("id");
  24.             String name = resultSet.getString("name");
  25.             System.out.print(id + "\t");
  26.             System.out.println(name);
  27.         }
  28.         JdbcUtil.close(connection,preparedStatement,resultSet);
  29.     }
  30. }

三、SQL注入【了解】

比如有时候写的删除或者修改sql又漏洞

delete from person where id = 1 or 1 = 1;

or 1 = 1;恒成立，条件相当于没写，这叫SQL注入

搬运工Statement不能防止这种情况

预处理的搬运工prepareStatement可以

为什么预处理搬运工可以？

  1. 因为SQL是预编译的，语句里面使用占位符“？”。 一个？是一个占位
  3. 2 or 1=1 三个占位，所以语法上就错了。
  1. package com.qfedu.test3;
  3. import com.qfedu.utils.JdbcUtil;
  5. import java.sql.Connection;
  6. import java.sql.PreparedStatement;
  7. import java.sql.SQLException;
  8. import java.sql.Statement;
  10. /**
  11.  * @author wodexinhuai
  12.  * @create 2022-04-27-14:21
  13.  */
  14. public class Demo1 {
  15.     public static void main(String[] args) throws SQLException {
  16. //        testStatement();
  17.         testPrepareStatement();
  18.     }
  19.     //搬运工 不能预防 全删
  20.     public static void testStatement() throws SQLException {
  21.         Connection connection = JdbcUtil.getConnection();
  22.         String id = "2 or 1 = 1";
  23.         String sql = "delete from person5 where id = " + id;
  24.         Statement statement = connection.createStatement();
  25.         int i = statement.executeUpdate(sql);
  26.         System.out.println(i);
  27.         JdbcUtil.close(connection,statement);
  28.     }
  29.     //预处理搬运工可以预防 报错
  30.     public static void testPrepareStatement() throws SQLException {
  31.         Connection connection = JdbcUtil.getConnection();
  32.         String sql = "delete from person3 where id = ?";
  33.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  34.         preparedStatement.setObject(1,"1 or 1 = 1");
  35.         int i = preparedStatement.executeUpdate();
  36.         JdbcUtil.close(connection,preparedStatement);
  37.     }
  38. }

注意！

查询的时候可以带1=1 以后会学动态SQL

删除和修改不能带1=1

四、javaBean规范和Beanutils类

4.1javaBean规范

javaBean就是java的实体类

写实体类的规范：

  1. 1.私有化成员变量
  3. 2.提供一个无参数的构造方法 如果没有有参构造可以不写 默认有
  5. 3.提供成员变量的set、get方法
  7. 4.每一个实体类单独成一个文件

4.2Beanutils类【重点】

在jdk里面没有这个类，说明不是jdk提供的。肯定是第三方提供的类，所以要导包

在官网https://mvnrepository.com/ 搜索Beanutils

commons-beanutils-1.9.3.jar

这个类是基于反射的类，是对实体进行赋值和取值的。

异常：ClassNotFoundException 出现这样的异常大部分原因是包没有导入完全

百度，然后在下载一个commons-logging-1.2.jar，导进去

案例

  1. package com.qfedu.test5BeanUtils;
  3. import com.qfedu.entity.Work;
  4. import org.apache.commons.beanutils.BeanUtils;
  6. import java.lang.reflect.InvocationTargetException;
  8. /**
  9.  * @author wodexinhuai
  10.  * @create 2022-04-27-14:59
  11.  */
  12. public class Demo1 {
  13.     public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
  14.         //对实体类的属性进行赋值和取值的
  15.         //
  16.         Work work = new Work();
  17.         //BeanUtils都是静态方法 不用new
  18.         //通过BeanUtils对work实体类进行赋值
  19.         //对work类下的id进行赋值1
  20.         BeanUtils.setProperty(work,"id",1);
  21.         BeanUtils.setProperty(work,"name","博儿");
  24.         //取值 work下的属性id的值
  25.         String id = BeanUtils.getProperty(work, "id");
  26.         String name = BeanUtils.getProperty(work, "name");
  27.         System.out.println(id);
  28.         System.out.println(name);
  29.     }
  30. }

最少需要导两个包，如果还有错误，根据百度需要什么包，在进行下载和导入

五、元数据【重点】

数据库的元数据【了解】 自己百度看看

参数元数据【重点】

结果集元数据【重点】

5.1参数元数据【重点】

获取预处理的搬运工对象的时候，处理SQL语句，参数化的的SQL语句，就是那个问号

Parameter 参数 MetaData 元数据

ParameterMetaData getParameterMetaData

  1. package com.qfedu.test6yuanshuju;
  3. import com.qfedu.utils.JdbcUtil;
  5. import java.sql.Connection;
  6. import java.sql.ParameterMetaData;
  7. import java.sql.PreparedStatement;
  8. import java.sql.SQLException;
  10. /**
  11.  * @author wodexinhuai
  12.  * @create 2022-04-27-15:48
  13.  */
  15. //参数元数据
  16. public class Demo1 {
  17.     public static void main(String[] args) throws SQLException {
  18.         Connection connection = JdbcUtil.getConnection();
  19.         String sql = "update work set name=?,age=?,info=? where id =?";
  20.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  21.         //getParameterMetaData 得到参数的元数据对象
  22.         ParameterMetaData parameterMetaData = preparedStatement.getParameterMetaData();
  23.         //可以获取SQL语句参数的个数 几个问号几个参数
  24.         int parameterCount = parameterMetaData.getParameterCount();
  25.         System.out.println(parameterCount);
  26.         //获取参数个数有啥用？通过循环给参数？进行赋值
  27.         Object[] objs = {"zzw",123,"hahahah",7};
  28.         for (int i = 1; i <= parameterCount; i++) {
  29.             preparedStatement.setObject(i,objs[i-1]);
  31.         }
  32.         int i = preparedStatement.executeUpdate();
  33.         System.out.println(i);
  34.         JdbcUtil.close(connection,preparedStatement);
  37.     }
  38. }

5.2结果集元数据【重点】

Result

  1. package com.qfedu.test6yuanshuju;
  3. import com.qfedu.utils.JdbcUtil;
  5. import java.sql.*;
  7. /**
  8.  * @author wodexinhuai
  9.  * @create 2022-04-27-16:09
  10.  */
  12. //结果集元数据
  13. public class Demo2 {
  14.     public static void main(String[] args) throws SQLException {
  15.         Connection connection = JdbcUtil.getConnection();
  16.         String sql = "select * from work";
  17.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  18.         ResultSet resultSet = preparedStatement.executeQuery();
  20.         //只能通过ResultSet对象获取结果集元数据对象 ResultSetMetaData
  21.         ResultSetMetaData metaData = resultSet.getMetaData();
  22.         //获取列（字段）的个数
  23.         int columnCount = metaData.getColumnCount();
  24. //        System.out.println(columnCount);//四个字段
  25.         //获取字段名字 结果集元数据.getColumnName()
  26. //        System.out.println(metaData.getColumnName(1));
  27. //        System.out.println(metaData.getColumnName(2));
  28. //        System.out.println(metaData.getColumnName(3));
  29. //        System.out.println(metaData.getColumnName(4));
  31.         //通过字段名字取数据
  32. //        while(resultSet.next()){
  33. //            for (int i = 1; i <= columnCount; i++) {
  34. //                for (int j = 1; j <= columnCount; j++) {
  35. //                    Object object = resultSet.getObject(metaData.getColumnName(j));
  36. //                    System.out.print(object + "\t");
  37. //                }
  38. //                System.out.println();
  39. //                break;
  40. //            }
  41. //        }
  42.         //while就是一层循环
  43.         while(resultSet.next()){
  44.             for (int i = 1; i <= columnCount; i++) {
  45.                 String columnName = metaData.getColumnName(i);
  46.                 System.out.print(resultSet.getObject(columnName) + "\t");
  47.             }
  48.             System.out.println();
  49.         }
  50.         JdbcUtil.close(connection,preparedStatement,resultSet);
  51.     }
  52. }