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

心已赠人 2023-10-09 23:43 26阅读 0赞

#### 目录 ####

*  引出
 *  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.单例封装数据库的三种方法；

--------------------

![在这里插入图片描述][983a4b0c6e544279a5270eaefdc329c6.png]

## JDBC：java连接 数据库 ##

### 1.连接数据库 ###

![在这里插入图片描述][f07760f042f34608bcfc6d500ca014a5.png]![在这里插入图片描述][76ee8d5f0ae34662a22cbcb6b5f9b167.png]![在这里插入图片描述][f22ae397b9b8411b9236c58fae0983b3.png]![在这里插入图片描述][418b079b58c14124a03e8dad201a4652.png]

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

**1）直接创建new**

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

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

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

**2）反射**

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

![在这里插入图片描述][5e18d959019a49cf975092fadc846be4.png]  
![在这里插入图片描述][7de9914f09f241d58f9352e6259572d5.png]

获取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");

#### 连接数据库方法 ####

![在这里插入图片描述][bd56baaaaefa421eba2030bbe0f12003.png]

> 类加载采用了反射的方式

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

![在这里插入图片描述][6cb251ae7c014855a3e42a564516f819.png]

### 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)\]][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)\]][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();
                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的六部曲，创建单例的方法及其封装应用；

[983a4b0c6e544279a5270eaefdc329c6.png]: https://img-blog.csdnimg.cn/983a4b0c6e544279a5270eaefdc329c6.png
[f07760f042f34608bcfc6d500ca014a5.png]: https://img-blog.csdnimg.cn/f07760f042f34608bcfc6d500ca014a5.png
[76ee8d5f0ae34662a22cbcb6b5f9b167.png]: https://img-blog.csdnimg.cn/76ee8d5f0ae34662a22cbcb6b5f9b167.png
[f22ae397b9b8411b9236c58fae0983b3.png]: https://img-blog.csdnimg.cn/f22ae397b9b8411b9236c58fae0983b3.png
[418b079b58c14124a03e8dad201a4652.png]: https://img-blog.csdnimg.cn/418b079b58c14124a03e8dad201a4652.png
[5e18d959019a49cf975092fadc846be4.png]: https://img-blog.csdnimg.cn/5e18d959019a49cf975092fadc846be4.png
[7de9914f09f241d58f9352e6259572d5.png]: https://img-blog.csdnimg.cn/7de9914f09f241d58f9352e6259572d5.png
[bd56baaaaefa421eba2030bbe0f12003.png]: https://img-blog.csdnimg.cn/bd56baaaaefa421eba2030bbe0f12003.png
[6cb251ae7c014855a3e42a564516f819.png]: https://img-blog.csdnimg.cn/6cb251ae7c014855a3e42a564516f819.png
[img-C6IBnBmB-1683902514958_D_javalearn_mdPictures_image-20230512204643739.png]: https://img-blog.csdnimg.cn/bf0e382a7536417db3022fe9f2def658.png
[img-YGmETYIN-1683902514959_D_javalearn_mdPictures_image-20230509115336619.png]: https://img-blog.csdnimg.cn/10c229de387d4a7b84b7beefed6bd8a3.png