2024年软件测试最全Java基础（7）——java连接SQL数据库 &amp；单例封装数据库(2)，2024年最新软件测试事件分发机制及设计思路

2401_84715926

已于 2024-05-08 21:04:00 修改

阅读量420

点赞数 3

分类专栏：程序员文章标签：数据库 java sql

于 2024-05-08 21:03:58 首次发布

本文链接：https://blog.csdn.net/2401_84715926/article/details/138586285

版权

程序员专栏收录该内容

126 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化的资料的朋友，可以戳这里获取

3.防止注入漏洞—prepareStatement

注意：序号从1开始，而不是0；

package com.tianju.test;

import java.sql.\*;
import java.util.Objects;
import java.util.Scanner;

public class JDBCDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 用户名登陆的注入漏洞
        Scanner sc = new Scanner(System.in);
        // 1.类加载
        Class.forName("com.mysql.cj.jdbc.Driver");

        // 2.第三方数据库连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://198.175.0.134:3306/emp\_db?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true",
                "root",
                "123"
        );
        Statement statement = conn.createStatement();

        // 3.处理业务逻辑

        // 查询-SQL注入漏洞
        String username = "admin";
        String password = "123";

        // 拼出sql语句
        String sql = "SELECT \* FROM user\_table u WHERE u.user\_username = ? AND u.user\_password = ?";

        // 防止注入代码的问题，用prepareStatement方法
        PreparedStatement pst = conn.prepareStatement(sql);
        pst.setObject(1, username); // 注意第一个从1开始
        pst.setObject(2, password);

		// rs.next()方法，获得表的内容
        ResultSet rs = pst.executeQuery();
        while (rs.next()){
            System.out.print(rs.getString("user\_name")+"\t|"
            + rs.getString("user\_password"));
        }

        // 4.进行关闭
        if (Objects.nonNull(rs)){
            rs.close();
        }
        if (Objects.nonNull(pst)){
            pst.close();
        }
        if (Objects.nonNull(conn)){
            conn.close();
        }

    }
}

单例封装数据库

1.JDBC六部曲

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C6IBnBmB-1683902514958)(D:\javalearn\思维导图笔记\mdPictures\image-20230512204643739.png)]$

2.补充：单例的创建方式

1）懒汉模式，需要加上synchronized同步锁

public class Singleton01 {
    private static Singleton01 instance = null;
    private Singleton01(){

    }
    // 如果加上synchronized：同步锁，就可以解决
    public static synchronized Singleton01 getInstance(){
        if (Objects.isNull(instance)){
            instance = new Singleton01();
        }
        return instance;
    }
}

2）饿汉模式，交给JVM处理

static只能初始化一次；JVM保证线程安全

public class Singleton02 {
    // 交给JVM进行处理，在创建static时会自动加锁，其他不能新建对象
    private static Singleton02 instance = new Singleton02();

    // 构造器私有化
    private Singleton02(){
    }

    public static Singleton02 getInstance(){
        return instance;
    }
}

3）利用枚举类型，static特性

补充：枚举类型

本质都是类

class
interface
enum

用于替代常量，规范编码

/\*\*
 \* 枚举类型
 \*/
public enum Day {
    Day01,Day02,Day03
}

valueOf()，转换成枚举类型；

values()，获得枚举的数组；

public class TestEnumDemo {
    public static void main(String[] args) {
        // Day.values()方法返回数组
        for(Day value:Day.values()){
            System.out.println(value);
        }
        // 将字符串转成枚举类型，valueOf 方法
        Day d = Day.valueOf("Day01");
        switch (d){
            case Day01:
                System.out.println("今天是星期一");
                break;
            case Day02:
                System.out.println("今天是星期二");
                break;
            case Day03:
                System.out.println("今天是星期三");
                break;
        }
    }
}

利用JVM底层实现

public enum Singleton03 {
    INSTANCE; // 利用枚举常量特性，枚举特性
    public void text(){
        System.out.println("hello，world");
    }
}

public class TestSington2 {
    public static void main(String[] args) {
        Singleton03.INSTANCE.text();
        System.out.println(Singleton03.INSTANCE.hashCode());
    }
}

反编译查看

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YGmETYIN-1683902514959)(D:\javalearn\思维导图笔记\mdPictures\image-20230509115336619.png)]$

public final class Hello extends java.lang.Enum<Hello> {
  public static final Hello INSTANCE;
  public static Hello[] values();
  public static Hello valueOf(java.lang.String);
  static {};
}

3.单例简易封装数据库

需求：JDBC进行如下SQL操作

-- 单例数据库封装
-- user_table 的增，删，改
-- 增加
INSERT INTO user\_table(user_username,user_password) VALUES ('keji','789');

-- 删除
DELETE FROM user_table WHERE user_username = 'keji';

-- 修改
UPDATE user_table SET user_name = '小鼋' WHERE user_id = '1';

-- emp_table 的查询
-- 查询在职且薪资大于4000的员工信息

SELECT \* FROM emp_table e WHERE e.emp_status = '在职' AND e.emp_sal > '6000';

1）采用枚举方式封装

方法程序：

package com.tianju.util;

import java.sql.\*;
import java.util.Objects;

/\*\*
 \* 采用枚举单例封装数据库
 \*/
public enum DbUtilEnum {
    INSTANCE;
    
    private Connection conn;
    private PreparedStatement pst;
    private ResultSet rs;


    private DbUtilEnum() {
        // 注册驱动-类加载
        register();
    }

    /\*\*
 \* 第一步：注册驱动，类加载
 \*/
    private void register(){
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    // 建立数据库连接
    // 192.168.0.134:3306
    // root，123
    /\*\*
 \* 第二步：建立数据库连接
 \* @param ipAdress ip地址+端口号
 \* @param user 用户名root
 \* @param password 密码123
 \*/
    public void connect(String ipAdress,String user,String password){
        String url = "jdbc:mysql://"+ipAdress+"/emp\_db?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
        try {
            conn = DriverManager.getConnection(url,user,password);
            System.out.println("成功连接数据库："+ipAdress);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }


    /\*\*
 \* 第三步：准备SQL语句，
 \* @param sql sql语句
 \*/
    public void setPreparedStatement(String sql, Object...values){
        try {
            pst = conn.prepareStatement(sql);
            // 逐个填充 ? 处的空缺
            for (int i=0;i<values.length;i++){
                pst.setObject(i+1, values[i]);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /\*\*
 \* 第四步：增加，删除，修改
 \*/
    public void executeUpdate(){
        try {
            pst.executeUpdate();
            System.out.println("执行增删改操作");
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /\*\*
 \* 第四步：查询ResultSet，调用next()方法
 \* @return 返回查询的ResultSet
 \*/
    public ResultSet executeQuery(){
        try {
            rs = pst.executeQuery();
            System.out.println("执行查询操作，返回结果");
            return rs;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /\*\*
 \* 第五步：关闭连接
 \*/
    public void close(){
        try {
            if (Objects.nonNull(rs)){
                rs.close();
            }
            if (Objects.nonNull(pst)){
                pst.close();
            }
            if (Objects.nonNull(conn)){
                conn.close();
            }
            System.out.println("操作完成，关闭数据库连接");
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

测试用例：

package com.tianju.test;

import com.tianju.util.DbUtilEnum;

import java.sql.ResultSet;
import java.sql.SQLException;

public class DbUtilEnumTest {
    public static void main(String[] args) {
        // 建立连接
        DbUtilEnum.INSTANCE.connect(
                "198.175.0.134:3306",
                "root",
                "123");
        // 增加数据
        String sql = "INSERT INTO user\_table(user\_username,user\_password) VALUES (?,?)";
        DbUtilEnum.INSTANCE.setPreparedStatement(sql, "rose","456");
        DbUtilEnum.INSTANCE.executeUpdate(); // 执行update操作
        DbUtilEnum.INSTANCE.close(); // 关闭连接
        
        // 删除数据
        String sql = "DELETE FROM user\_table WHERE user\_username = ? ";
        DbUtilEnum.INSTANCE.setPreparedStatement(sql, "rose");
        DbUtilEnum.INSTANCE.executeUpdate(); // 执行update操作
        DbUtilEnum.INSTANCE.close(); // 关闭连接

        // 修改数据
        String sql = "UPDATE user\_table SET user\_name = ? WHERE user\_id = ?";
        DbUtilEnum.INSTANCE.setPreparedStatement(sql, "rose",1);
        DbUtilEnum.INSTANCE.executeUpdate(); // 执行update操作
        DbUtilEnum.INSTANCE.close(); // 关闭连接

        // 查询数据
        String sql = "SELECT \* FROM emp\_table e WHERE e.emp\_status = ? AND e.emp\_sal > ?";
        DbUtilEnum.INSTANCE.setPreparedStatement(sql,"在职",5000);
        ResultSet rs = DbUtilEnum.INSTANCE.executeQuery(); // 执行Query操作
        // 显示数据
        while(true){
            try {
                if (!rs.next()) break;
                System.out.println(rs.getString("emp\_name")+"\t"+
                        rs.getInt("emp\_age") +"\t"+
                        rs.getDouble("emp\_sal"));
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }

        }
        DbUtilEnum.INSTANCE.close(); // 关闭连接

    }
}

2）采用饿汉模式封装

方法程序：

package com.tianju.util;

import java.sql.\*;
import java.util.Objects;

public class DbUtilStatic {
    // 交给JVM处理
    private static DbUtilStatic instance = new DbUtilStatic();
    private Connection conn;
    private PreparedStatement pst;
    private ResultSet rs;

    // 构造器私有化
    private DbUtilStatic() {
        // 注册驱动-类加载
        register();
    }

    public static DbUtilStatic getInstance(){
        return instance;
    }

    /\*\*
 \* 第一步：注册驱动，类加载
 \*/
    private void register(){
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    // 建立数据库连接
    // root，123
    /\*\*
 \* 第二步：建立数据库连接
 \* @param ipAdress ip地址+端口号
 \* @param user 用户名root
 \* @param password 密码123
 \*/
    public void connect(String ipAdress,String user,String password){
        String url = "jdbc:mysql://"+ipAdress+"/emp\_db?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
        try {
            conn = DriverManager.getConnection(url,user,password);
            System.out.println("成功连接数据库："+ipAdress);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }


    /\*\*
 \* 第三步：准备SQL语句，
 \* @param sql sql语句
 \*/
    public void setPreparedStatement(String sql, Object...values){
        try {
            pst = conn.prepareStatement(sql);
            // 逐个填充 ? 处的空缺
            for (int i=0;i<values.length;i++){
                pst.setObject(i+1, values[i]);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /\*\*
 \* 第四步：增加，删除，修改
 \*/
    public void executeUpdate(){
        try {
            pst.executeUpdate();
            System.out.println("执行增删改操作");
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /\*\*
 \* 第四步：查询ResultSet，调用next()方法
 \* @return 返回查询的ResultSet
 \*/
    public ResultSet executeQuery(){
        try {
            rs = pst.executeQuery();


![img](https://img-blog.csdnimg.cn/img_convert/6f80ddf66e62871a6415677712b72cc9.png)
![img](https://img-blog.csdnimg.cn/img_convert/d18dc08dc3429295a0add9fe74ed69ed.png)
![img](https://i-blog.csdnimg.cn/blog_migrate/df74b239dfa4add7e16327a0976bcaca.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

e);
        }
    }

    /\*\*
 \* 第四步：查询ResultSet，调用next()方法
 \* @return 返回查询的ResultSet
 \*/
    public ResultSet executeQuery(){
        try {
            rs = pst.executeQuery();


[外链图片转存中...(img-hRHVfrhf-1715173422894)]
[外链图片转存中...(img-WyRyTCOx-1715173422895)]
[外链图片转存中...(img-5NHrolP3-1715173422895)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**