Perley620

Java基础（7）——java连接SQL数据库 & 单例封装数据库

引出
JDBC：java连接数据库
- 1.连接数据库
- - 补充：创建对象的三种方式
  - - **3）Class.forName(类名)【调用static代码块中的代码】**
  - 连接数据库方法
- 2.注入漏洞—executeQuery
- 3.防止注入漏洞—prepareStatement
单例封装数据库
- 1.JDBC六部曲
- 2.补充：单例的创建方式
- - 1）懒汉模式，需要加上synchronized同步锁
  - 2）饿汉模式，交给JVM处理
  - 3）利用枚举类型，static特性
- 3.单例简易封装数据库
- - 1）采用枚举方式封装
  - 2）采用饿汉模式封装
  - 3）采用懒汉模式封装
总结

引出

1.Java如何连接数据库；
2.注入漏洞的问题，以及防止；
3.单例封装数据库的三种方法；

JDBC：java连接数据库

1.连接数据库

补充：创建对象的三种方式

1）直接创建new

Car.java 编译成 Car.clase 类加载到 JVM 中，加载时还没有创建对象；

进入JVM中给类Car创建单独的唯一的对象Class 类，该Class对象中存储了Car类的一些必要信息，没有记录相关的值；

以Class对象生产成多个Car对象，通过Class类映射出多个Car对象

2）反射

一个类会产生一个唯一的Class对象，JVM底层原理

获取Class对象的方式

// 不知道类型用？简写Class c = Car.class;
Class<?> c = Car.class;
// new对象之后再获取Clss
Class<?> C = new Car().getClass();

System.out.println(c);
System.out.println(C);

作用创建对象：

// 1.创建对象
Car x = (Car) c.newInstance();
System.out.println(x);

3）Class.forName(类名)【调用static代码块中的代码】

// 通过包的包名加类名即可拿到
Class<?> clazz = Class.forName("com.tianju.entity.Car");
Car y = (Car) clazz.newInstance();
System.out.println(y);

【调用static代码块中的代码】

Pig类

public class Pig {
    // 静态代码块
    static { // JVM 的 Pig对象的 Class
        System.out.println("静态代码块");
    }

    {
        System.out.println("代码块");
    }
}

测试：

// 静态代码块执行1次，代码块执行2次
new Pig();
new Pig();

// 虚拟机什么时候把Class
Class.forName("com.tianju.entity.Pig");
Class.forName("com.tianju.entity.Pig");

连接数据库方法

类加载采用了反射的方式

package com.tianju.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Objects;

public class JDBCDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 1.类加载
        Class.forName("com.mysql.cj.jdbc.Driver");
        // 2.第三方数据库连接+ip地址+数据库名
        Connection conn = DriverManager.getConnection("jdbc:mysql://198.175.0.134:3306/emp_db?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true",
                "root",
                "123"
        );
        // 3.关闭连接
        if (Objects.nonNull(conn)){
            conn.close();
        }

    }
}

2.注入漏洞—executeQuery

’ OR 1='1

package com.tianju.test;

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

public class JDBCDemo2 {
    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注入漏洞
        System.out.println("用户名");
        String username = sc.nextLine();
        System.out.println("密码");
        String password = sc.nextLine();

        // 拼出sql语句
        String sql = "SELECT * FROM user_table u WHERE u.user_name = '"
                +username+"' AND u.user_password = '"+password+"';";

        ResultSet rs = statement.executeQuery(sql);
        if (rs.next()){ // 找到第一行数据
            // 注入漏洞 ' OR 1='1
            System.out.println("欢迎"+rs.getString("user_name"));
        }else {
            System.out.println("用户名|密码错误");
        }

        // 3.关闭连接——逐层逆向关闭
        if (Objects.nonNull(rs)){
            rs.close();
        }
        if (Objects.nonNull(statement)){
            statement.close();
        }
        if (Objects.nonNull(conn)){
            conn.close();
        }
    }
}

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());
    }
}

反编译查看

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）采用饿汉模式封装