数据库——JDBC的正确打开方式

数据库驱动

应用程序通过数据库驱动和数据库连接，数据库驱动由数据库厂商提供

JDBC是 Java 访问数据库的标准规范，真正怎么操作数据库还需要具体的实现类，也就是数据库驱动。

在Java中，数据库存取技术（应用程序储存和读取数据库里的数据的技术）可分为下面几类：
1、JDBC直接访问数据库
2、JDO技术（Java Data Object）
3、第三方 O/R工具,如Hibernate,Mybatis等

JDBC是java访问数据库的基石，JDO，Hibernate等只是为了更好地封装JDBC

一、JDBC简介

JDBC：Java数据库连接（Java Database Connectivity）

SUN公司为了简化开发人员对数据库的操作，提供了一个（Java操作数据库的）技术规范，俗称JDBC

JDBC是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口(一组API)，

提供了诸如查询和更新数据库中数据的方法,定义了用来访问数据库的标准java类库，使用这个类库可以以一种标准的方法，方便的访问数据库资源。

我们通常说的JDBC是面向关系型数据库的。

JDBC用处：我们用JAVA就能连接到数据库，创建SQL或者MYSQL语句，执行并得到查看和修改结果记录。

使用JDBC的好处：

1、程序员如果要开发访问数据库的程序，只需要会调用 JDBC 接口中的方法即可，不用关注类是如何实现的。

2、使用同一套 Java代码，进行少量的修改就可以访问其他 JDBC 支持的数据库

二、测试第一个JDBC程序

1、先建一个数据库

CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;
USE jdbcStudy;
CREATE TABLE `users`(
    id INT PRIMARY KEY,
    NAME VARCHAR(40),
    PASSWORD VARCHAR(40),
    email VARCHAR(60),
    birthday DATE
);
INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)
VALUES(1,'zhansan','123456','zs@sina.com','1980-12-04'),
(2,'lisi','123456','lisi@sina.com','1981-12-04'),
(3,'wangwu','123456','wangwu@sina.com','1979-12-04')

2、用IDEA创建一个普通项目（JDBC）
3、在JDBC项目下建一个lib目录


4、导入一个MySQL数据库驱动包==（什么版本的数据库就下什么版本的驱动包,注意要导入jar文件）下载链接

将驱动包导入到lib目录下（复制粘贴就行）

导入后一定要添加到项目的库里面才能生效

5.在src目录下编写测试代码

package com.peng.cheng;
import java.sql.*;
// 我的第一个JDBC程序：查询user表中的全部信息
public class JDBCFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");//固定写法，加载驱动
        //2.填写用户信息和url，用来连接数据库，默认情况下是没有连接的
        //用?来连接参数    参数的含义useUnicode=true支持中文编码 ，characterEncoding=Utf8设置字符集编码为Utf8 ，useSSl=true使用安全的连接
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=Utf8&useSSl=false";
        String username = "root"; //用户名
        String password = "123456"; // 密码
        //3.连接成功，返回数据库对象  Connection代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //4.获得执行SQl的对象  Statement:执行SQl的对象
        Statement statement = connection.createStatement();
        //5.用执行SQl的对象去执行SQL语句,可能存在返回结果
        String sql = "SELECT * FROM `users`";
        ResultSet resultSet = statement.executeQuery(sql); //ResultSet:返回的结果集,结果集中封装了我们所有查询出来的结果
         //把结果集中的结果拿出来  遍历 拿到数据库中的表
        while (resultSet.next()){
            System.out.println("id=" + resultSet.getObject("id"));
            System.out.println("name=" + resultSet.getObject("NAME"));
            System.out.println("pwd=" + resultSet.getObject("PASSWORD"));
            System.out.println("email=" + resultSet.getObject("email"));
            System.out.println("birthday=" + resultSet.getObject("birthday"));
        }
        //6.释放连接，必须做，用完关掉，不然耗资源
        resultSet.close();
        statement.close();
        connection.close();
    }
}

执行结果

id=1
name=zhansan
pwd=123456
email=zs@sina.com
birthday=1980-12-04
id=2
name=lisi
pwd=123456
email=lisi@sina.com
birthday=1981-12-04
id=3
name=wangwu
pwd=123456
email=wangwu@sina.com
birthday=1979-12-04

三、JDBC中核心对象的解释

1、DriverManager作用：管理和注册驱动

//DriverManager 
//1.注册，加载驱动   DriverManage管理驱动  registerDriver注册驱动      
Class.forName("com.mysql.jdbc.Driver");//推荐使用固定写法
       /*举个例子来解释Driver对象   
       DriverManage.registerDriver(new com .mysql.jdbc.Driver());//原来的写法，不建议使用
        解释：使用Class.forName()会将调用的类初始化，即调用class中的static静态代码块，并返回该类的Class对象，
        比如 com.mysql.jdbc.Driver中代码，当调用Class.forName(“com.mysql.jdbc.Driver”)时，Driver类中static部分就会被调用，
        再来看Driver类的源码：
         static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    源码里已经java.sql.DriverManager.registerDriver(new Driver());已经注册驱动了，直接调用就行
    而DriverManage.registerDriver(new com .mysql.jdbc.Driver());这种写法将会注册重复注册驱动，所以不推荐使用，
    通过这个例子就可以知道DriverManagerr对象的作用了！

2、URL(Uniform Resource Locator)统一资源定位符

//mysql格式："jdbc:mysql://主机地址:端口号/数据库名？参数1&参数2&参数3
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=Utf8&useSSl=true";
//"jdbc:mysql:用来连接MySQL的协议       localhost:3306  地址加端口号    
//mysql默认端口号是3306    Oracle默认端口号是1521
//Oracle格式："jdbc:oracle:thin:@localhost:1521:sid

3、Connection获取数据库驱动对象

//DriverManager作用： 创建数据库的连接
// Connection代表数据库，可以做数据库能做的事情
Connection connection = DriverManager.getConnection(url, username, password);
connection.commit();//事务提交
connection.rollback();//事务回滚
connection.setAutoCommit(true);//设置事务自动提交

4、Statement:执行SQl的对象

//4.获得执行SQl的对象  Statement:执行SQl的对象    prepareStatement();//也是执行SQl的对象
Statement statement = connection.createStatement();
connection.prepareStatement();//也是执行SQl的对象
//statement中的方法
statement.executeQuery();//查询操作，返回一个结果集resultset
statement.execute();//执行任何SQL，但效率低
statement.executeUpdate();//更新，插入，删除都用这个，返回一个受影响的行数
int num=statement.executeQuery(sql)
if(num>0){  //如果受影响的行数大于0，则说明修改成功
   System.out.println("修改成功");   
}

5、ResultSet查询的结果集：封装了所有的查询结果

String sql = "SELECT * FROM `users`";
ResultSet resultSet = statement.executeQuery(sql); //ResultSet:返回的结果集,结果集中封装了我们所有查询出来的结果
//方法
resultSet.getObject();//在不知道列类型的情况下使用
// 如果知道列的类型就使用指定的类型
resultSet.getString();//varchar
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();
......
//遍历拿出结果，指针    
resultSet.next()//移动到下一个数据
resultSet.beforeFirst();//指针移动到最前面
resultSet.afterLast();//指针移动到最后面
resultSet.previous();//指针移动到前一行
resultSet.absolute();//指针移动到指定行，就可以拿到指定的数据

四、创建JDBC工具类

package com.peng.cheng.lesson02.utils;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
//建这个类用来加载配置文件，这个类就是工具类
public class JdbcUtils {
    //提升作用域
    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;
    static {//获取配置文件资源
        try { //          返回一个输入流                 获得类加载器+       获得具体的资源        资源名就是配置文件名，配置文件最好提出来单独放放
            InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties properties = new Properties();
            properties.load(inputStream);//加载文件
            //从properties里获取资源
            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");
            //1.加载驱动，只用加载一次
            Class.forName(driver);//这里直接用配置文件里的driver=com.mysql.jdbc.Driver
        } catch (Exception  e) {
            e.printStackTrace();
        }
    }
    //2.获取连接方法
    //             返回值
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);//通过连接字符串，用户名，密码来得到数据 库的连接对象
    }
    //释放资源
    public static void release(Connection conn, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    }

配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://lcalhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSl=true
username=root
password=123456

五、测试JDBC工具类

1、JDBC工具类测试插入操作

package com.peng.cheng.lesson01;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
//JDBC工具类测试插入操作
public class TestInster {
    public static void main(String[] args) {
        //因为在try里面返回的变量是释放不到的，所以要提到最上面来
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {//这里也可以把异常抛出，就不用提变量了，捕获是为了处理异常，所以尽量不要为了不处理而抛出异常
            conn = JdbcUtils.getConnection(); //JdbcUtils工具包调用getConnection连接数据库的方法，拿到数据库的对象，获取连接
            st = conn.createStatement(); //通过数据库对象来创建Statement执行SQL语句对象
            String sql = "INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                    "VALUES(6,'惊鸿','123456','123456qq@.com','2020-02-09')";
            int i;
            i = st.executeUpdate(sql);//执行SQl语句,返回一个受影响的行数，更新，插入，删除都用这个，返回一个受影响的行数
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);//关闭连接，释放资源
        }
    }
}

2、测试删除操作

package com.peng.cheng.lesson01;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
//JDBC测试删除操作
public class TestDelete {
    public static void main(String[] args)  {
        Connection conn = null;
        Statement  st = null;
        //1.获取连接
        try {
            conn = JdbcUtils.getConnection(); //返回一个数据库对象conn
            //2.获取执行SQl语句的对象
            st = conn.createStatement();
            //3.编写SQL语句
            String sql = ("DELETE FROM `users` WHERE id =4");
            int i = st.executeUpdate(sql);//返回一个受影响的行数  更新，插入，删除都用这个，返回一个受影响的行数
            if (i>0){
                System.out.println("删除成功");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        //释放资源
        JdbcUtils.release(conn,st,null);
    }
}

4、测试修改操作

package com.peng.cheng.lesson01;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
//测试修改操作
public class TestUpdate {
    public static void main(String[] args) throws SQLException {
        //1.获取连接
        Connection conn = JdbcUtils.getConnection();
        //2.创建执行SQL语句对象
        Statement st = conn.createStatement();
        //3.编写SQL语句
        String sql=("UPDATE `users` SET `NAME`='长安', `PASSWORD`='111222'  WHERE id =3");
        int i = st.executeUpdate(sql);
        if (i>0){
            System.out.println("修改成功");
        }
        JdbcUtils.release(conn,st,null);//释放资源
    }
}

5、测试查询操作（和第一个程序对比，有工具类比没工具类方便很多）

package com.peng.cheng.lesson01;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
//测试查询操作
public class TestSelect {
    public static void main(String[] args)  {
        Connection conn = null;
        Statement  st = null;
        ResultSet  rs = null;
        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();
            String sql ="SELECT `NAME`,`PASSWORD` FROM `users` WHERE id =1";
            rs = st.executeQuery(sql);
            while(rs.next()){
                System.out.println("name="+rs.getString("NAME"));
                System.out.println("password="+rs.getString("PASSWORD"));
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        JdbcUtils.release(conn,st,rs);
    }
}

六、SQL注入的问题

SQL存在漏洞，会被攻击导致数据泄露
1、本质：因为or的原因，SQl语句会被拼接，从而实现非法操作

package com.peng.cheng.lesson01;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class SQLInjection {
    public static void main(String[] args) {
       // login("长安","111222");正常登录
        login(" 'or '1=1 ","'or '1=1");//SQL注入方式登录
    }
    //登录业务
    public static void login(String username ,String password){
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();
            //SELECT  * FROM users WHERE `NAME`='长安'AND`PASSWORD`='111222' AND id=2
            //输入的姓名，密码为''（空）或者1=1（真），所以name和password永远等于true， 相当于SELECT  * FROM users WHERE  true
            //SELECT  * FROM users WHERE `NAME`=''or '1=1' AND `PASSWORD`=''or '1=1'
            String sql ="SELECT  * FROM users WHERE `NAME`='"+username+"' AND `PASSWORD`='"+password+"' ";
            rs = st.executeQuery(sql);
            while(rs.next()){
                System.out.println(rs.getString("NAME"));
                System.out.println(rs.getString("password"));
                System.out.println("===========================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        JdbcUtils.release(conn,st,rs);
    }
}

2、结果(查出了表中所有的信息)

zhansan
123456
===========================
长安
111222
===========================
惊鸿
123456
===========================
惊鸿
123456
===========================

点击跳转sql注入百科

七、PreparedStatetment详解

1、PreparedStatement 是 Statement的子类，继承于父类中所有的方法。它是一个预编译的 SQL 语句

prepareStatement()会先将 SQL 语句发送给数据库预编译。PreparedStatement 会引用着预编译后的结果。可以多次传入不同的参数给 PreparedStatement 对象并执行。减少 SQL 编译次数，提高效率。

可以有效的防止 SQL 注入的问题，安全性更高，提高了程序的可读性。

2、PreparedStatement测试

增

package com.peng.cheng.lesson03;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.*;
import java.util.Date;
//测试PreparedStatement新增操作
// PreparedStatement是继承了Statement的子类
public class TestInster {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection();
            //                                                                         使用?号占位符代替参数
            String sql = " INSERT INTO users (`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(?,?,?,?,?) ";
            pst = conn.prepareStatement(sql);//传一个预编译的sql，先写SQL语句，然后不执行
            //手动给参数赋值，可以多次传入不同的参数给PreparedStatement 对象并执行
            pst.setInt(1, 5);
            pst.setString(2, "神明");
            pst.setInt(3, 123456);
            pst.setString(4, "1111@.qq.com");
            pst.setDate(5, new java.sql.Date(new Date().getTime()));
            /*new Date()是java.util包下的,要转换成sql包下的数据库使用的时间日期    new Date().getTime()获得时间戳
             java.util.Date对象转换为java.sql.Date对象举例：
             Date date4 = new Date();
             java.sql.Date date5 = new java.sql.Date(date4.getTime());
            */
            //执行,直接调用执行的方法
            int i = pst.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            {  JdbcUtils.release(conn, pst, null);
            }
        }
    }
}

删

package com.peng.cheng.lesson03;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
//测试PreparedStatement删除操作
public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pst = null;
        try {
            conn = JdbcUtils.getConnection();
            //
            String sql = " DELETE FROM users WHERE id =? ";
            pst = conn.prepareStatement(sql);//传一个预编译的sql，先写SQL语句，然后不执行
            //手动给参数赋值
            pst.setInt(1, 3);
            //执行
            int i = pst.executeUpdate();
            if (i > 0) {
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            {  JdbcUtils.release(conn, pst,null);
            }
        }
    }
}

改

package com.peng.cheng.lesson03;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
//测试PreparedStatement修改操作
public class TestUpdate {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pst = null;
        try {
            conn = JdbcUtils.getConnection();
            //                                 使用?号占位符代替参数
            String sql = " UPDATE users SET `NAME`=?,`PASSWORD`=? WHERE id=?";
            pst = conn.prepareStatement(sql);//传一个预编译的sql，先写SQL语句，然后不执行
            //手动给参数赋值
            pst.setString(1, "风起");
            pst.setString(2,"111222");
            pst.setInt(3,1);
            //执行
            int i = pst.executeUpdate();
            if (i > 0) {
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            {  JdbcUtils.release(conn, pst,null);
            }
        }
    }
}

查

package com.peng.cheng.lesson03;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
//测试PreparedStatement查询操作
public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rs= null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = " SELECT * FROM users WHERE id =? ";
            pst = conn.prepareStatement(sql);//传一个预编译的sql，先写SQL语句，然后不执行
            //手动给参数赋值
            pst.setInt(1, 1);
            //执行
             rs = pst.executeQuery();
            if(rs.next()){
                System.out.println("id = "+rs.getInt("id"));
                System.out.println("name = "+rs.getString("name"));
                System.out.println("password = "+rs.getString("password"));
                System.out.println("email = "+rs.getString("email"));
                System.out.println("birthday = "+rs.getString("birthday"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, pst,null);
            {
            }
        }
    }
}

preparedStatement测试SQl注入问题：

PreparedStatement防止SQL注入的本质==：把传递进来的参数当做字符，假设其中存在转义字符，会被直接忽略掉，假如是’’(引号)则会被直接转义

package com.peng.cheng.lesson03;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.*;
//PreparedStatement测试SQL注入问题
public class SQLInjection2 {
    public static void main(String[] args) {
      // login("长安","111222");  //正常登录
        login(" 'or '1=1 ","'or '1=1");//SQL注入方式登录,结果不能获取到信息，解决了sql注入问题
    }
    //登录业务
    public static void login(String username ,String password) {
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "select * from users where `NAME`=? and `PASSWORD`=?";
            pst = conn.prepareStatement(sql);//预编译
            //赋值
            pst.setString(1, username);
            pst.setString(2, password);
            //执行
            rs = pst.executeQuery();
            while (rs.next()) {
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, pst, rs);
        }
    }
}

八、JDBC操作事务

package com.peng.cheng.lesson04;
import com.peng.cheng.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
//测试JDBC操作事务
public class TestAffair {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement pst=null;
        ResultSet rs=null;
        try {
            conn = JdbcUtils.getConnection();
            //1.关闭数据库的事物自动提交功能,在java里面，关闭自动提交后会默认开启事务
            conn.setAutoCommit(false);
            String sql1="UPDATE account SET money=money-500 WHERE `name`='A'" ; // A减500
            pst = conn.prepareStatement(sql1);//预编译
            pst.executeUpdate();
            //int x=1/0; 万能的报错语句，加上后业务会执行失败，事务会回滚
            String sql2="UPDATE account SET money=money+500 WHERE `name`='B'" ; // B减500
            pst=conn.prepareStatement(sql2);//预编译
            pst.executeUpdate();
            //业务完毕，提交事务
            conn.commit();
            System.out.println("操作成功");
        } catch (SQLException e) {
            try {
                conn.rollback();//如果业务执行失败，则事务回滚，回到最初的数据状态。不在catch语句中显示定义也会默认回滚
            } catch (SQLException e1) {
                e.printStackTrace();
            }
            e.printStackTrace();
        }finally {
           JdbcUtils.release(conn,pst,rs);
        }
    }
}

十、用Sqlyog工具可视化运行步骤,并和JDBC作比较

一.连接数据库

对应JDBC的第1,2步：加载驱动和填写用户信息和url，连接数据库

二.编写SQL语句并执行

对应JDBC的第3，4，5步

​ 3.连接成功，返回数据库对象

​ 4.获得执行SQl的对象

​ 5.用执行SQl的对象去执行SQL语句,可能存在返回结果

总结：

JDBC是在代码层面上操作的

Sqlyog是在可视化层面上操作的

但是两个本质上还是去编写这个程序