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.连接数据库

Java基础(7)——java连接SQL数据库 & 单例封装数据库_第1张图片Java基础(7)——java连接SQL数据库 & 单例封装数据库_第2张图片在这里插入图片描述Java基础(7)——java连接SQL数据库 & 单例封装数据库_第3张图片

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

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

Java基础(7)——java连接SQL数据库 & 单例封装数据库_第4张图片

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

反编译查看

Java基础(7)——java连接SQL数据库 & 单例封装数据库_第5张图片

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

}

3)采用懒汉模式封装

方法程序,简略

package com.tianju.util;

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

public class DbUtilSyLock {
    private static DbUtilSyLock instance = null;
    private DbUtilSyLock(){
        register();
    }

    /**
     * 加入synchronized锁
     * @return 返回引用
     */
    public static synchronized DbUtilSyLock getInstance(){
        if (Objects.isNull(instance)){
            instance = new DbUtilSyLock();
        }
        return instance;
    }

总结

1.创建对象的三种方式,反射,Class.forName();
2.SQL查询注入漏洞的问题,以及防止方法;
3.prepareStatement在填充?时序号从1开始;
4.JDBC的六部曲,创建单例的方法及其封装应用;

你可能感兴趣的:(Java,java,数据库,学习)