[大数据] JDBC学习

Java Database Connectivity，是对数据库的连接。JDBC规范了接口，具体的实现类由数据库厂商来实现。

使用的包：

JDBC的核心API：

?JDBC的API打通数据库：

连接java连接数据库的步骤：

声明执行sql语句的对象:

Statement ?接口:

executeUpdate:使用Statement执行DDL和DML语句区别在于执行DDL语句返回值为0，执行DML语句后返回值为受影响的记录条数。

executeQuery:该方法会得到ResultSet对象, JDBC使用ResultSet对象封装数据库查询的结果集，通过移动ResultSet的记录指针来取出结果集的内容, 对结果集进行遍历。

ResultSet是个结果集,其中next（）方法是判断是否有下一行，最开始的时候是指向第一行的前面的。

常见的数据转化：（相应的方法里面可以是索引（从1开始），也可以是字段名字）

注意：目前我们用的日期在数据库里面是用字符串表示的，所以，在jdbc里面获取的时候是getstring。?

import java.sql.*;

public class connection {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String user = "root";
        String password = "123456";
//        URL：协议+主机+端口+路径+参数
        String url = "jdbc:mysql://localhost:3306/focusone?useSSl=false&serverTimezone = Asia/Shanghai";
//        01:加载驱动类:驱动类由数据库厂家提供
        Class.forName("com.mysql.cj.jdbc.Driver");
//        02:利用驱动管理类建立要连接的数据库的对象。
        Connection connection = DriverManager.getConnection(url, user, password);
//        System.out.println(connection);//调用tostring方法
//        03:创建执行sql语句的对象Statement：执行sql语句；
        Statement statement = connection.createStatement();
//        04:
//        executeUpdate()方法执行sql语句：
        int i = statement.executeUpdate("create table 电磁感应(id int,name varchar(3))");//DDL
        System.out.println("受影响的行："+i);
        int i1 = statement.executeUpdate("insert into 电磁感应 values (123,'di')");//DML
        System.out.println("受影响的行："+i1);
//        executeQuery()方法执行sql语句：
        ResultSet resultSet = statement.executeQuery("select * from 电磁感应");//DQL
        while (resultSet.next()){//遍历结果集对象
            System.out.print(resultSet.getInt(1)+"\t");
            System.out.print(resultSet.getString(2)+"\t");
        }
//       05：关闭结果集、声明对象和连接：
        resultSet.close();
        statement.close();
        connection.close();
    }
}

sql语句的注入问题：?

本质：sql语句要输入的地方有sql的关键字，在数据库执行的时候，被当成了关键字所造成的。

上述语句 where后面变为条件1 and 条件2 or true , 无论用户名和密码的条件1和条件2是否为true,最后都进行了逻辑或操作 ,'1'='1'?为true , 整个where就是true。（and的优先级大于or）。

reparedStatement需要使用问号占位符来代替Statement中需要拼接进入sql的参数.

import java.net.ConnectException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class preparestatement {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //连接数据库：
        String user = "root";
        String password = "123456";
        String url = "jdbc:mysql://localhost:3306/focusone?useSSl=false&serverTimezone = Asia/Shanghai";
        Class.forName("com.mysql.cj.jdbc.Driver");
        Connection connection = DriverManager.getConnection(url, user, password);
        //根据sql语句创建预编译对象：
        String sql = "insert into 电磁感应 values (?,?)"; //?相当于占位符
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //设置占位符的值；
        preparedStatement.setInt(1, 124);
        preparedStatement.setString(2, "lll");//注意这里必须是字符串类型==>双引号
        //执行：
        int i = preparedStatement.executeUpdate();
        System.out.println("受影响的行："+i);
//        关：
        preparedStatement.close();
        connection.close();
    }
}

封装工具类——连接和关闭：

import javax.swing.*;
import java.net.ConnectException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class javatool {
    private static final String user = "root";
    private static final String password = "123456";
    private static final String url = "jdbc:mysql://localhost:3306/focusone?useSSl=false&serverTimezone = Asia/Shanghai";
    private static final String driver =  "co.mysql.cj.jdbc.Driver";
    //加载驱动类：做工具类，编译器异常不能上抛。
    static {
        try {
            Class.forName(driver);
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("加载驱动类失败，请查看类名或者是否导入包");
        }
    }
    //获取数据库连接：
    public static Connection getcon(){
        try {
            Connection connection = DriverManager.getConnection(url, user, password);
            return connection;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            throw new RuntimeException("获取数据库连接失败");
            //把编译期的异常转换成运行期异常，调用着不必声明或是处理这个异常,遇见这个异常就停了吧。
            //目的，是为了让调）用者得到一个正确的连接（这是根本）
            //需要声明的都是编译器异常（必须处理），所以抛出运行期异常一般不处理
        }
    }
    //关闭声明对象和连接：
    public static void release(Statement statement, Connection connection){
        if(statement != null){
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(connection != null){
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

}

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
class singer {
    private Integer sid;
    private String sname;
    private String sex;
    private Double salary;
    private String birthday;
    private String display;

    public singer() {
    }

    public singer(Integer sid, String sname, String sex, Double salary, String birthday, String display) {
        this.sid = sid;
        this.sname = sname;
        this.sex = sex;
        this.salary = salary;
        this.birthday = birthday;
        this.display = display;
    }

    public Integer getSid() {
        return sid;
    }

    public String getSname() {
        return sname;
    }

    public String getSex() {
        return sex;
    }

    public Double getSalary() {
        return salary;
    }

    public String getBirthday() {
        return birthday;
    }

    public String getDisplay() {
        return display;
    }

    @Override
    public String toString() {
        return "singer{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", sex='" + sex + '\'' +
                ", salary=" + salary +
                ", birthday='" + birthday + '\'' +
                ", display='" + display + '\'' +
                '}';
    }
}
public class query {
    public static List<singer> getinformation() throws SQLException {
        Connection connection = javatool.getcon();
        String sql = "select * from tsinger where sex = ?";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setString(1, "女");//不能用单引号，也不能没有双引号
        ResultSet resultSet = preparedStatement.executeQuery();//获得结果集对象
        List<singer> list = new ArrayList<>();
        while (resultSet.next()){
            int anInt = resultSet.getInt(1);
            String string = resultSet.getString(2);
            String string1 = resultSet.getString(3);
            double aDouble = resultSet.getDouble(4);
            String string2 = resultSet.getString(5);
            String string3 = resultSet.getString(6);
            singer singer = new singer(anInt,string, string1, aDouble, string2,string3);
            list.add(singer);
        }
        return list;
    }
}
class  test01{
    public static void main(String[] args) throws SQLException {
        List<singer> getinformation = query.getinformation();
        for(singer i :getinformation){
            System.out.println(i);
        }

    }
}

查看结果集的表结构ResultSetMetaData：

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class resultmetadate {
    public static void main(String[] args) throws SQLException {
        Connection getcon = javatool.getcon();
        //执行sql对象
        Statement statement = getcon.createStatement();
        String sql = "select * from tsinger";
        //获得结果集：
        ResultSet resultSet = statement.executeQuery(sql);
        ResultSetMetaData metaData = resultSet.getMetaData();
        //获取列数：
        int columnCount = metaData.getColumnCount();
        for (int i = 1; i <= columnCount; i++) {//索引从1开始；
            System.out.print(metaData.getColumnName(i)+"\t");
        }
        System.out.println();
        while (resultSet.next()){//?：是一行
            for (int i = 1; i <=columnCount ; i++){
                System.out.print(resultSet.getObject(i));//获得一个单元格的内容
                //获得的object对象属于上转型对象，在调用tostring方法的时候，是调用子类重写的。

            }
            System.out.println();
        }
        javatool.release(statement, resultSet, getcon);
    }
}

JDBC处理存储过程：

CallableStatement接口：通过connection.prepareCall(sql模板)方法获得。（preparestatement的子类）

?演示：

import java.lang.reflect.Type;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Types;

public class procedure {
    public static void main(String[] args) throws SQLException {
        Connection getcon = javatool.getcon();
//        in sidp INT,in newdisplay VARCHAR(20),OUT sum INT
        String sql = "call pro10(?,?,?)";
        CallableStatement callableStatement = getcon.prepareCall(sql);
        //设置入参：
        callableStatement.setInt(1, 1001);
        callableStatement.setString(2, "我真帅");
        //注册返回值：
        callableStatement.registerOutParameter(3, Types.INTEGER);
        //执行
        callableStatement.execute();//不清楚查询语句的类性的时候，用execute
        //获得返回值：
        int anInt = callableStatement.getInt(3);
        System.out.println(anInt);
        javatool.release(callableStatement, getcon);
    }
}

?处理blob类型数据：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class blod {
    public static void main(String[] args) throws FileNotFoundException, SQLException {
        //获取文件：
        File file = new File("C:\\Users\\Lenovo\\Desktop\\02.png");
        String filename = file.getName();
        FileInputStream fileInputStream = new FileInputStream(file);
        Connection connection = javatool.getcon();
        String sql = "insert into tab_file values (?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //设置值
        preparedStatement.setInt(1, 111);
        preparedStatement.setString(2, filename);
        preparedStatement.setBinaryStream(3, fileInputStream);
        //执行
        int i = preparedStatement.executeUpdate();
        System.out.println(i);
        javatool.release(preparedStatement, connection);
    }
}

向外输出BLOB：

import java.io.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class bolbin {
    public static void main(String[] args) throws SQLException, IOException {
        //字节流对于视频和图片的输入和输出
        File file = new File("E:\\02.png");
        Connection getcon = javatool.getcon();
        String sql = "select * from tab_file where file_id = 11";
        PreparedStatement preparedStatement = getcon.prepareStatement(sql);
        ResultSet rs = preparedStatement.executeQuery();
        if(rs.next()){
            FileOutputStream fos = new FileOutputStream(file);//内存读取到外存
            InputStream binaryStream = rs.getBinaryStream(3);//数据库到内存
            byte[] b = new byte[100];
            int len = -1;
            while((len = binaryStream.read(b)) != -1){
                fos.write(b, 0, len);
            }
            fos.close();
            binaryStream.close();
        }
        javatool.release(preparedStatement, getcon);
    }

}

JBDC处理事务：

连接池：解决频繁开启和关闭连接造成的数据库的性能下降：