转载

JDBC：你总得学着去连接数据库！

JDBC ：带它再爱你一次

(一) JDBC 入门

(1) 概述

Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范 客户端 程序如何来 访问数据库 的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。JDBC是 面向关系型 数据库的。

简单解释：通过Java语言执行sql语句，从而操作数据库

(2) 来由

想要通过Java操作不同的数据库，应该根据数据库的不同而执行特定的API，而出于简化的想法，Sun公司，定义了一套面向所有关系型数据库的 API 即 JDBC ，其只提供接口，而具体实现去交给数据库厂商实现，而我们作为开发者，我们针对数据数据库的操作，只需要基于JDBC即可

(二) 简单使用 JDBC

我们简单的使用JDBC去查询数据库中的数据，并且输出到控制台中

为了快速演示，我们新建一张非常简单的表

CREATE TABLE student(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(20),
    score DOUBLE(4,1)
);

INSERT student(id,NAME,score) VALUES (1,'张三',98);

INSERT student(id,NAME,score) VALUES (2,'李四',96);

INSERT student(id,NAME,score) VALUES (3,'王五',100);

我们根据数据库中的信息写一个对应的学生类

public class Student {
    private int id;
    private String name;
    private double score;
    //省略构造、Get、Set、toString方法
    ...... 
}

下面是对 JDBC 查询功能的简单使用

package cn.ideal.jdbc;

import cn.ideal.domain.Student;

import java.sql.*;

public class JdbcDemo {
    public static void main(String[] args) {
        //导入数据库驱动包

        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            //加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取与数据库的连接对象
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", "root99");
            //定义sql语句
            String sql = "SELECT * FROM student";
            //获取执行sql语句的对象statement
            statement = connection.createStatement();
            //执行sql语句，获取结果集
            resultSet = statement.executeQuery(sql);

            //遍历获取到的结果集
            while (resultSet.next()) {
                int id = resultSet.getInt(1);
                String name = resultSet.getString(2);
                Double score = resultSet.getDouble(3);

                Student student = new Student();
                student.setId(id);
                student.setName(name);
                student.setScore(score);

                System.out.println(student.toString());
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //释放资源，后调用的先释放
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//运行结果
Student{id=1, name='张三', score=98.0}
Student{id=2, name='李四', score=96.0}
Student{id=3, name='王五', score=100.0}

下面我们开始详细的解释一下上面所用到的各个对象

(三) JDBC 对象详解

(1) DriverManager

A：加载驱动 --> 注册驱动

首先我们要知道加载驱动和注册驱动这两个词是什么意思，刚刚接触的时候，会有人总有朋友将 Class.forName(com.mysql.jdbc.Driver) 当做注册数据库驱动的语句，但实际不然，它的作用是将参数表示的类加载到内存中，并且 初始化 ，同时其中的静态变量也会被初始化，静态代码块也会被执行

  • 疑惑：能否使用ClassLoader 类中的loadClass()方法呢？

    • 答案是否定的，这个方法的特点是加载但不对该类初始化
//Class类源码节选 -jdk8
* A call to {@code forName("X")} causes the class named
* {@code X} to be initialized.

关于初始化问题这里简单提及一下，我们还是先回到我们主线来

为什么不对类进行初始化，就不能选择了呢？

这是因为真正实现 注册驱动 （告诉程序使用哪一个数据库驱动jar）的是: 

static void registerDriver(Driver driver)

我们在jar包中找到Driver这个类，查看其源码

//com.mysql.jdbc.Driver类中的静态代码块
static {
    try {
        DriverManager.registerDriver(new Driver());
    } catch (SQLException var1) {
        throw new RuntimeException("Can't register driver!");
    }
}

类被加载后，执行了类中的静态方法DriverManager进行了注册驱动

我们也可能有见过下面2中的代码，但是实际上驱动会被加载两次，因为执行

new com.mysql.jdbc.Driver() 已经加载了一次驱动 

//1.推荐
Class.forName("com.mysql.jdbc.Driver");
//2.不推荐
DriverManager.registerDriver(new com.mysql.jdbc.Driver())

那么何必这么麻烦呢？ new com.mysql.jdbc.Driver() 直接这样写不就挺好了吗？

但我们还是选择 拒绝！为什么呢？

如果我们这样写，对于jar包的依赖就比较重了，我们如果面临多个项目，或者需要修改数据库，就需要修改代码，重新编译，但是如果使用Class类加载的方式，既保证了静态代码块中所包含的注册驱动方法会被执行 ，而又将参数变成了字符串形式，我们之后便可以通过修改配置文件 “ ” 内的内容 + 添加jar包 的方式更灵活的处理问题，并且不需要重新编译！

注意：mysql5之后的驱动jar包可以省略注册驱动这一步，原因查看jar包中META-INF/services/java.sql.Driver文件

com.mysql.jdbc.Driver
com.mysql.fabric.jdbc.FabricMySQLDriver

B：获取数据库连接

static Connection getConnection(String url, String user, String password) 
/*
    jdbc:mysql://ip地址(域名):端口号/数据库名称
    Eg:jdbc:mysql://localhost:3306/db1
    本地mysql，且端口为默认3306，则可简写：jdbc:mysql:///数据库名称
*/

(2) Connection (数据库连接对象)

A：获取执行sql的对象

//创建向数据库发送sql语句的statement对象
Statement createStatement()

//创建向数据库发送预编译sql语句的PrepareStement对象
PreparedStatement prepareStatement(String sql)

B：管理事务

//开启事务：设置参数为false，即开启事务
setAutoCommit(boolean autoCommit) 

//提交事务
commit() 

//回滚事务
rollback()

(3) Statement (执行sql语句的对象)

//执行DQL（查询数据库中表的记录(数据)）
ResultSet executeQuery(String sql)

//执行DML（对数据库中表的数据进行增删改）
int executeUpdate(String sql)

//执行任意sql语句，但是目标不够明确，较少使用
boolean execute(String sql)

//把多条sql的语句放到同一个批处理中
addBatch(String sql)

//向数据库总发送一批sql语句执行
executeBatch()

代码演示（以增加一条数据为例）

package cn.ideal.jdbc;

import java.sql.*;

public class StatementDemo {
    public static void main(String[] args) {

        Connection connection = null;
        Statement statement = null;
        try {
            //加载驱动
            Class.forName("com.mysql.jdbc.Driver");

            //获取数据库连接对象
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", "root99");

            //定义sql语句
            String sql = "INSERT student(id,NAME,score) VALUES (NULL,'马六',88);";

            //获取执行sql语句的对象
            statement = connection.createStatement();

            //执行sql语句
            int count = statement.executeUpdate(sql);
            System.out.println(count);
            if (count > 0) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            if(statement != null){
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if (connection != null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

(4) ResultSet（结果集对象，封装查询结果）

ResultSet所代表的的是sql语句的结果集——执行结果，当Statement对象执行excuteQuery()后，会返回一个ResultSet对象

//游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)
//如果是，则返回false，如果不是则返回true
boolean next()

//获取数据，Xxx代表数据类型  
getXxx(参数)

Eg:int getInt() ,    String getString()
    
1. int：代表列的编号,从1开始   如： getString(1)
2. String：代表列名称。 如： getDouble("name")

案例可参考开头快速使用部分，自行尝试读取数据库中数据后用集合框架装载

(四) 事半功倍——工具类

通过封装一些方法，使得出现一个更加通用的工具类，我们可以通过properties配置文件 ，使得信息更加直观且容易维护

package cn.ideal.jdbc;

import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;

public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;

    /**
     * 文件读取
     */
    static {

        try {
            //创建Properties集合类
            Properties pro = new Properties();
            //获取src路径下的文件
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL res = classLoader.getResource("jdbc.properties");
            String path = res.getPath();

            //加载文件
            pro.load(new FileReader(path));
            //获取数据
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");

            //注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    /**
     * 获取连接
     *
     * @return 连接对象
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, user, password);
    }

    /**
     * 释放资源
     *
     * @param statement
     * @param connection
     */
    public static void close(Statement statement, Connection connection) {
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 释放资源
     *
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

工具类测试类

package cn.ideal.jdbc;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCUtilsTest {
    public static void main(String[] args) {

        Connection connection = null;
        Statement statement = null;
        try {

            connection = JDBCUtils.getConnection();

            //定义sql语句
            String sql = "INSERT student(id,NAME,score) VALUES (NULL,'马六',88)";

            //获取执行sql语句的对象
            statement = connection.createStatement();

            //执行sql语句
            int count = statement.executeUpdate(sql);
            System.out.println(count);
            if (count > 0) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(statement,connection);
        }
    }
}

之前的文章中分别通过集合实现、IO实现、而学习数据库后，我们可以试着通过数据库存储数据，写一个简单的登录注册小案例！在第五大点中有提到吼

(五) 补充：PreparedStatment

//创建向数据库发送预编译sql语句的prepareStatement
PreparedStatement prepareStatement(String sql)

prepareStatement继承自Statement，总而言之，它相较于其父类，更强更简单！

(1) 优点

A：效率

Statement 直接编译 SQL 语句，直接送到数据库去执行，而且其多次重复执行sql语句，PreparedStatement 会 对SQL进行预编译 ，再填充参数，这样效率会比较高（ 预编译的SQL存储在PreparedStatement中 ）

B：可读性

定义 SQL 语句的时候，常常需要使用到 Java 中的变量，在一些复杂的情况下，需要频繁的使用到引号和单引号的问题，变量越多，越复杂，而PreparedStatement可以使 用占位符 ‘ ？’ 代替参数，接下来再进行参数的赋值，这样有利于代码的可读性

C：安全性

PreparedStatement 由于预编译，可以避免Statement中可能需要采取字符串与变量的拼接而导致SQL注入攻击【编写永等式，绕过密码登录】

我们先按照我们之前的做法，写一个简单的登录Demo，先创一张表！

CREATE TABLE USER(
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(32),
    PASSWORD VARCHAR(32)
);

SELECT * FROM USER;

INSERT INTO USER VALUES(NULL,'admin','admin888');
INSERT INTO USER VALUES(NULL,'zhangsan','123456');

接着编写代码

package cn.ideal.login;

import cn.ideal.jdbc.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;

public class LoginDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名");
        String username = sc.nextLine();
        System.out.println("请输入密码");
        String password = sc.nextLine();
        
        boolean flag = new LoginDemo().login(username, password);

        if (flag) {
            System.out.println("登录成功");
        } else {
            System.out.println("用户名或密码错误");
        }
    }

    /**
     * 登录方法
     */
    public boolean login(String username, String password) {
        if (username == null || password == null) {
            return false;
        }

        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JDBCUtils.getConnection();
            //定义sql
            String sql = "SELECT * FROM USER WHERE username = '" + username + "' AND password = '" + password + "' ";
            //获取执行sql的对象
            statement = connection.createStatement();
            //执行查询
            resultSet = statement.executeQuery(sql);

            return resultSet.next();

        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.close(resultSet,statement, connection);
        }
        return false;
    }
}

简单的来说，这样一个简单的登录Demo就写好了，但是这个时候，SQL注入问题中的一种情况就出现了，或许你听过，在早些年的时候，漏洞还是蛮常见的，一些黑客或者脚本小子们常常使用一些SQL注入的手段进行目标网站后台的入侵，我们今天所讲的这一种，就是其中一种，叫做SQL万能注入（SQL万能密码）

我们先来观察一下上述代码中关于SQL语句的部分

String sql = "SELECT * FROM USER WHERE username = '" + username + "' AND password = '" + password + "' ";

也就是说它将我们所输入的 username 和 password 合成为SQL查询语句， 当数据库中不存在这样的字段就代表输入错误，但是对于存在SQL注入漏洞的程序，则可以通过构造一些特殊的字符串，达到登录的目的，先贴出来测试结果 

//运行结果
请输入用户名
admin
请输入密码
1' or '1' = '1
登录成功

如果我们将上述代码中密码 (username) 部分用我们的这些内容代替是怎么样的呢

String sql = "SELECT * FROM USER WHERE username = 'admin' AND PASSWORD = '1' or '1' = '1' ";

补充：在SQL语句中逻辑运算符具有优先级，= 优先于 and ，and 优先于 or

所以上面的式子中 AND先被执行，当然返回错，接着执行or部分，对于一个永等式 ‘1’ = ‘1‘ 来说返回值永远是true，所以SQL查询结果为true，即可以登录成功

//使用PrepareStemen替代主要部分

//定义sql
String sql = "SELECT * FROM USER WHERE username = ? AND password = ?";
//获取执行sql的对象
preparedStatement = connection.prepareStatement(sql);
//给?赋值
preparedStatement.setString(1, username);
preparedStatement.setString(2, password);

//执行查询
resultSet = preparedStatement.executeQuery();

//运行结果
请输入用户名
admin
请输入密码
1' or '1' = '1
用户名或密码错误

​

结尾：

如果内容中有什么不足，或者错误的地方，欢迎大家给我留言提出意见, 蟹蟹大家 ！^_^

如果能帮到你的话，那就来关注我吧！（系列文章均会在公众号第一时间更新）

一个坚持推送原创Java技术的公众号：理想二旬不止

JDBC：你总得学着去连接数据库！

原文  https://segmentfault.com/a/1190000019965475
正文到此结束
所属分类： Java 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：623 人
  • 运行天数：4,408天
  • 最后更新：2024年11月21日21点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG