Java学习：JDBC

jdbc简介

DBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，使用这个类库可以以一种标准的方法、方便地访问数据库资源。

jdbc的核心API

Driver接口：数据库驱动程序的接口，所有的数据库厂商需要的驱动程序需要实现此接口。

Connection接口：与具体的数据库连接对象；

Statement createStatement()    创建一个静态sql语句对象

PreparedStatement prepareStatement(String sql)  创建预编译的sql语句对象

CallableStatement prepareCall(String sql)   创建存储过程的sql语句对象

Statement接口：用于执行静态 SQL 语句

int executeUpdate(String sql)  执行更新操作的sql语句 （create/alter/drop) DDL语句

                                             　　　　　　　　　　　(insert/update/delete）DML语句

ResultSet executeQuery(String sql)  执行查询操作的sql语句

　　　　　　　　　　　　　　　　　　　　　　　　　　　(select)（DQL查询语句）

PreparedStatement接口：用于执行预编译的 SQL 语句（是Statement的子接口）

int executeUpdate()  执行更新操作的sql语句

ResultSet executeQuery()  执行查询操作的sql语句

CallableStatement接口：用于执行 SQL 存储过程的接口（是PreparedStatement的子 接口）

ResultSet executeQuery()  执行存储过程的sql语句

ResultSet接口：结果集对象。 存储所有数据库查询的结果，用该对象进行数据遍历。

boolean next() ： 把光标移动到下一行。如果下一行有数据，返回true，如果没有下一行数 据，返回false。

getXXX（列索引|列字段名称）： 获取字段的数据

Jdbc编程步骤：

1、加载数据库驱动

Class.ForName(driveClass)

上面的driveClass就是数据库驱动类对应的类路径字符串，

2、通过DriverManager获取数据库的链接

DriverManager.getConnection(String url, Stirng user, String pass)

当使用DriverManager来获取链接，需要传入三个参数：分别是数据量的url、用户名、密码。

用此方法获取数据库的链接

public class DriverDemo {
    private static String url = "jdbc:mysql://localhost:3306/day20";
    //jdbc协议:mysql协议://主机地址:端口号/需要连接的数据库名称
    private static String user = "root";
    private static String password="root";
    
    public static void main(String[] args) throws Exception {
        /**
         * java程序连接mysql数据库
         * 1.mysql数据库的主机地址
         * 2.端口号
         * 3.用户名
         * 5.密码
         * 6.需要连接的数据库
         * 
         * 需求：先使用java程序连接我们的数据库，需要一个连接对象Connection
         */
        conn3();
    }
private static void conn3() throws Exception {
        //注册驱动，我们发现mysql驱动程序的Driver实现类已经帮我们在静态代码块中注册好了驱动，
        //我们在此时只需要将Driver实现类加载到我们的内存中，static代码块就会自动执行，我们的驱动也就自动注册了
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        
        //获取java连接数据库的对象
        Connection conn = DriverManager.getConnection(url, user, password);
        
        //打印这个连接对象
        System.out.println(conn);
        
    }

3、通过Connection对象创建Statement对象，Connection创建Statement的方法如下三个：

createStatement()创建基本的Statement对象。

prepareStatement(String sql)：根据传入的sql语句创建预编译的Statement对象。

prepareCall(String sql)：根据传入的sql语句创建CallableStatement对象。

4、Statement执行SQL语句，Statement有三大方法来执行SQL语句：

execute：可以执行任何SQL语句，单比较麻烦

executeUpdate：可以执行DML、DDL语句。执行DML返回受影响的SQL语句行数，执行DDL返回0；

（create/alter/drop) DDL语句

 (insert/update/delete）DML语句

executeQuery：只能执行查询语句DQL，执行后返回代表查询结果的ResultSet对象。

先创建基本的Statement对象。然后通过executeUpdate执行DML、DDL语句。

public class Demo {
    private static String url = "jdbc:mysql://localhost:3306/day19";
    private static String user = "root";
    private static String password = "root";
    
    public static void main(String[] args){
        Connection conn = null;
        Statement stmt = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //通过驱动管理类获取数据库连接
            conn = DriverManager.getConnection(url, user, password);
            
            //创建语句执行者
            stmt = conn.createStatement();
            //int executeUpdate(String sql)
            //throws SQLException执行给定 SQL 语句，
            //该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。
            String sql = "CREATE TABLE student1("+
                            "id INT,"+
                            "NAME VARCHAR(20),"+
                            "age INT"+
                            ");";
            
            //使用语句执行者执行创建的sql语句
            int count = stmt.executeUpdate(sql);
            
            //打印一下影响的结果
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            //释放资源
            if (conn!=null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            if (stmt!=null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
        }    
    }

}

public class Demo2 {
    private static String url = "jdbc:mysql://localhost:3306/day20";
    private static String user = "root";
    private static String password = "root";
    
    public static void main(String[] args) {
        testInsert();//给数据库添加一条记录
        testUpdate();//修改数据库中的一条数据
        testDelete();
    }

    private static void testDelete() {

        //需求：将刘德华改为岳云鹏
        Connection conn = null;
        Statement stmt = null;
        
        try{
            //2.获取连接对象
            conn  =JDBCUtil.getConn();
            //3.准备sql
            String sql = "DELETE FROM student WHERE id=1;";
            //4.获取语句执行者
            stmt = conn.createStatement();
            //5.发送兵长执行sql
            int count = stmt.executeUpdate(sql);
            //打印影响的行数
            System.out.println(count);
            
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            JDBCUtil.close(conn, stmt, null);
        }
        
    
        
    }

    private static void testUpdate() {
        //需求：将刘德华改为岳云鹏
        Connection conn = null;
        Statement stmt = null;
        
        try{
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn  =DriverManager.getConnection(url, user, password);
            //3.准备sql
            String sql = "UPDATE student SET NAME='岳云鹏' WHERE id=1;";
            //4.获取语句执行者
            stmt = conn.createStatement();
            //5.发送兵长执行sql
            int count = stmt.executeUpdate(sql);
            //打印影响的行数
            System.out.println(count);
            
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            if (conn!=null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            if (stmt!=null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

    private static void testInsert() {
        //专门测试添加功能
        Connection conn = null;
        Statement stmt = null;
        try{
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            conn = DriverManager.getConnection(url, user, password);
            //定义sql
            String sql = "INSERT INTO student VALUES(1,'刘德华',50);";
            //获取语句执行者
            stmt = conn.createStatement();
            //使用语句执行者发送并执行sql语句,并返回影响的行数
            int count = stmt.executeUpdate(sql);
            System.out.println(count);
            
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            //释放资源
            if (conn!=null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            if (stmt!=null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

}

为了使程序员对数据库的操作方便可将注册驱动，获取连接数据库对象，释放资源等操作抓取成功一个类

package com.jdbc.Util;

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

public class JDBCUtil {
    private static String url = "jdbc:mysql://localhost:3306/day20";
    private static String user = "root";
    private static String password = "root";
    
    static{
        //随着类的加载而夹在
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    //获取连接
    public static Connection getConn(){
        //注册驱动
        try {
            Connection conn = DriverManager.getConnection(url, user, password);
            return conn;        
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new RuntimeException();
        }
        
    }
    
    
    //释放资源
    public static void close(Connection conn,Statement stmt,ResultSet rs){
        if (conn!=null) {
            try {
                conn.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        if (stmt!=null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        if (rs!=null) {
            try {
                rs.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

通过executeQuery执行DQL语句，利用next（）方法判断是否有下一行数据

public class Demo3 {
    
    public static void main(String[] args) {
        //定义一个连接对象和一个语句执行者
        Connection conn  =null;
        Statement stmt = null;
        ResultSet rs = null;
        try{
            conn = JDBCUtil.getConn();
            //定义sql
            String sql = "SELECT * FROM student;";
            //获取语句执行者对象
            stmt = conn.createStatement();
            //执行DQL查询语句
            //ResultSet executeQuery(String sql)
            //throws SQLException执行给定的 SQL 语句，该语句返回单个 ResultSet 对象。
            rs = stmt.executeQuery(sql);
            //ResultSet是一个结果集
            /*//判断有没有下一行数据
            if (rs.next()) {
                //说明有下一行数数据
                System.out.println(rs.getInt(1)+"--"+rs.getString(2)+"--"+rs.getInt(3));
            }
            
            if (rs.next()) {
                //说明有下一行数数据
                System.out.println(rs.getInt(1)+"--"+rs.getString(2)+"--"+rs.getInt(3));
            }
            
            if (rs.next()) {
                //说明有下一行数数据
                System.out.println(rs.getInt(1)+"--"+rs.getString(2)+"--"+rs.getInt(3));
            }
            
            if (rs.next()) {
                //说明有下一行数数据
                System.out.println(rs.getInt(1)+"--"+rs.getString(2)+"--"+rs.getInt(3));
            }
            
            if (rs.next()) {
                //说明有下一行数数据
                System.out.println(rs.getInt(1)+"--"+rs.getString(2)+"--"+rs.getInt(3));
            }*/
            
            //使用while循环改进上面的代码,获取字段的数据(字段类型+列号)
/*            while (rs.next()) {
                System.out.println(rs.getInt(1)+"--"+rs.getString(2)+"--"+rs.getInt(3));
            }*/
            
            //使用字段名称获取字段的每一个数据
            while (rs.next()) {
                //当我们使用字段名称去获取字段数据的时候，字段名称是不区分大小写
                System.out.println(rs.getInt("ID")+"--"+rs.getString("NAME")+"--"+rs.getInt("AGE"));
            }
            
            
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, rs);
        }
        
    }

}

还可以通过

PreparedStatement prepareStatement(String sql)  

定义预编译sql语句对象，并通过setInt()方法 发送参数并执行sql语句。

package com.jdbc.c_preparedstatement;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import com.jdbc.Util.JDBCUtil;

public class Demo {
    public static void main(String[] args) {
        testInsert();
        testUpdate();
        testDelete();
        testSelect();
    }

    private static void testSelect() {
        Connection conn  =null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try{
            //获取连接
            conn  = JDBCUtil.getConn();
            //定义预编译sql
            String sql = "SELECT * FROM student WHERE id=?;";
            //获取预编译sql对象
            stmt = conn.prepareStatement(sql);
            //给问好赋值
            stmt.setInt(1, 3);
            //发送参数并执行sql语句
            //ResultSet executeQuery()throws SQLException在此 
            //PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
            rs = stmt.executeQuery();
            //遍历结果集
            while (rs.next()) {
                System.out.println(rs.getInt("id")+"--"+rs.getString("name")+"--"+rs.getInt("age"));
            }
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, rs);
        }

    
    }

    private static void testDelete() {

        Connection conn  =null;
        PreparedStatement stmt = null;
        
        try{
            conn = JDBCUtil.getConn();
            //写一个参数化的sql
            String sql = "DELETE FROM student WHERE id=?;";
            //获取预编译的sql对象
            stmt = conn.prepareStatement(sql);
            //给？设置参数
            stmt.setInt(1, 2);
            //发送参数并执行sql
            int count = stmt.executeUpdate();
            System.out.println(count);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, null);
        }

    }

    private static void testUpdate() {
        Connection conn  =null;
        PreparedStatement stmt = null;
        
        try{
            conn = JDBCUtil.getConn();
            String sql = "UPDATE student SET NAME=? WHERE id=?;";
            //执行预编译sql
            stmt = conn.prepareStatement(sql);
            //给？赋值
            stmt.setString(1, "张学友");
            stmt.setInt(2, 5);
            //发送参数到数据库服务器，并执行sql,将执行结果返回
            int count = stmt.executeUpdate();
            System.out.println(count);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, null);
        }
        
        
    }

    private static void testInsert() {
        //定义连接对象和预编译sql对象
        Connection conn  = null;
        PreparedStatement stmt = null;
        
        try{
            //获取连接
            conn = JDBCUtil.getConn();
            //PreparedStatement prepareStatement(String sql)
            //throws SQLException创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。
            String sql = "INSERT INTO student VALUES(?,?,?);";//参数化的sql,动态sql
            stmt = conn.prepareStatement(sql);//需要一个预编译的sequel语句，将sq发送到数据库端，检查sql语法及用户权限等信息
            
            //给之前参数化的sql语句设置参数
            //两个参数：1：是给第几个？设置数据    2：给？设置的数据
            stmt.setInt(1, 5);
            stmt.setString(2, "黎明");
            stmt.setInt(3, 60);
            //int executeUpdate()throws SQLException
            int count = stmt.executeUpdate();
            System.out.println(count);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //释放资源
            JDBCUtil.close(conn, stmt, null);
        }
        
    }

}

利用此预编译的sql对象的特性可以改进sql的注入行为

package com.jdbc.c_preparedstatement;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;

import com.jdbc.Util.JDBCUtil;

public class Login {
    //SELECT * FROM USER WHERE userName='james' OR 1=1 -- ' AND PASSWORD='123456';
    //sql注入行为
    private static String user = "james' OR 1=1 -- ";
    private static String password = "123456";
    public static void main(String[] args) {
        //testStatement();
        testPreparedStatement();
    }

    private static void testPreparedStatement() {
        Connection conn  =null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        
        try{
            conn  =JDBCUtil.getConn();
            String sql = "SELECT * FROM USER WHERE userName=? AND PASSWORD=?;";
            stmt = conn.prepareStatement(sql);
            //给问号设置参数
            stmt.setString(1, user);
            stmt.setString(2, password);
            //发送参数并执行sql
            rs = stmt.executeQuery();
            if (rs.next()) {
                System.out.println("登陆成功");
            }else {
                System.out.println("登录失败");
            }
            
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, rs);
        }
    }

    private static void testStatement() {
        Connection conn  =null;
        Statement stmt = null;
        ResultSet rs = null;
        try{
            conn = JDBCUtil.getConn();
            stmt = conn.createStatement();
            String sql  ="SELECT * FROM USER WHERE userName='"+user+"' AND PASSWORD='"+password+"';";
            rs = stmt.executeQuery(sql);
            if (rs.next()) {
                System.out.println("登陆成功");
            }else {
                System.out.println("登录失败");
            }
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, rs);
        }
    }

}

通过

CallableStatement prepareCall(String sql)   创建存储过程的sql语句对象

package com.jdbc.d_callablestatement;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;

import com.jdbc.Util.JDBCUtil;

public class Demo {
    public static void main(String[] args) {
        执行带有输入参数存储过程
        //testIn();
        //执行带有输出参数的存储过程
        testOut();
    }

    private static void testOut() {

        Connection conn  =null;
        CallableStatement stmt = null;
        ResultSet rs = null;
        try{
            conn = JDBCUtil.getConn();
            String sql = "CALL pro_QueryNameById(?,?);";
            stmt = conn.prepareCall(sql);
            //给问号赋值
            stmt.setInt(1, 2);
            //如果存储过程带有输出参数的时候，首先需要注册，输出参数的类型
            //void registerOutParameter(int parameterIndex,int sqlType)
            stmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            
            //发送参数并执行sql
            stmt.executeQuery();
            
            //从stmt中取出输出参数的结果
            System.out.println(stmt.getString(2));
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //释放资源
            JDBCUtil.close(conn, stmt, rs);
        }
    }

    private static void testIn() {
        Connection conn  =null;
        CallableStatement stmt = null;
        ResultSet rs = null;
        try{
            conn = JDBCUtil.getConn();
            String sql = "CALL pro_QueryById(?);";
            stmt = conn.prepareCall(sql);
            
            //给问号设置值
            stmt.setInt(1, 2);
            //发送参数并执行sql,只能调用excuteQuery()
            rs = stmt.executeQuery();
            if (rs.next()) {
                System.out.println(rs.getInt(1)+"--"+rs.getString(2));
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //释放资源
            JDBCUtil.close(conn, stmt, rs);
        }
        
    }

}

 JDBC进行批处理

有时我们需要向数据库发送一批sql语句，这是我们用JDBC的批处理机制会大大增加我们的效率。

Statement批处理：

void addBatch(String sql)  添加sql到缓存区（暂时不发送）

int[] executeBatch() 执行批处理命令。 发送所有缓存区的sql

void clearBatch()  清空sql缓存区

 

PreparedStatement批处理：

void addBatch() 添加参数到缓存区

int[] executeBatch() 执行批处理命令。 发送所有缓存区的sql

void clearBatch()  清空sql缓存区

 mysql不支持批处理，就不做展示了

JDBC获取自增长值

使用两个参数的prepareStatement（）方法，指定可以返回自动增长的键值

 * Statement.RETURN_GENERATED_KEYS: 可以返回自动增长值

 * Statement.NO_GENERATED_KEYS: 不能返回自动增长值

        /**
         * 1.给部门表中插入一个新的部门“财务部”
         * 2.获取财务部对应的id
         * 3.给员工表中插入一条员工数据，对应的部门就是财务部对应的id
         */
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try{
            conn  =JDBCUtil.getConn();
            String sql1 = "insert into dept(deptName) values(?)";
            String sql2 = "insert into employee(name,deptId) values(?,?);";
            //先给部门表中插入一条数据
            //PreparedStatement prepareStatement(String sql,int autoGeneratedKeys)
            stmt  = conn.prepareStatement(sql1, Statement.RETURN_GENERATED_KEYS);
            stmt.setString(1, "财务部");
            stmt.executeUpdate();
            //获取自增长的键值
            //ResultSet getGeneratedKeys()
            rs = stmt.getGeneratedKeys();//rs就是一个自增站的键的一个结果集
            int deptId = 0;
            while (rs.next()) {
                deptId = rs.getInt(1);
            }
            //给员工表中插入一条数据
            stmt = conn.prepareStatement(sql2);
            stmt.setString(1, "岳云鹏");
            stmt.setInt(2, deptId);
            //发送参数并执行sql
            stmt.executeUpdate();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //释放资源
        }
        
    

JDBC处理大数据文件

大容量的字符字段：

mysql：text（64k）    longtext（4G字符内容）

oracle：clob    longclob

字节字段

mysql：blob（64kb）  meduimblob（16mb）  longblob（4GB）

oracle：blob

public static void main(String[] args) {
        //需求：将一篇文章存储到数据库中
        //write();
        read();
    }

    private static void read() {

        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try{
            //获取连接
            conn  = JDBCUtil.getConn();
            String sql = "select * from news";
            stmt = conn.prepareStatement(sql);
            //执行sql 
            rs = stmt.executeQuery();
            //便利结果集
            while (rs.next()) {
                //获取content字段的数据
                Reader reader = rs.getCharacterStream(2);
                //创建文件输出流对象
                FileWriter fw = new FileWriter("D://url2.txt");
                //边度边写
                char[] chs = new char[1024];
                int len;
                while ((len=reader.read(chs))!=-1) {
                    fw.write(chs, 0, len);
                    //刷新
                    fw.flush();
                }
                
                //关流
                fw.close();
                reader.close();
                
            }
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //释放资源
            JDBCUtil.close(conn, stmt, null);
        }
        
    
        
    }

    private static void write() {
        Connection conn = null;
        PreparedStatement stmt = null;
        
        try{
            conn  = JDBCUtil.getConn();
            String sql = "insert into news values(?,?);";
            stmt = conn.prepareStatement(sql);
            //设之参数
            stmt.setString(1, "随便一句话");
            stmt.setClob(2, new FileReader("D://url.txt"));
            //发送参数，并执行sql 
            int count = stmt.executeUpdate();
            System.out.println(count);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //释放资源
            JDBCUtil.close(conn, stmt, null);
        }
        
    }

    public static void main(String[] args) {
        write();//给数据库中存出一张图片
        //read();
    }

    private static void read() {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try{
            conn  = JDBCUtil.getConn();
            String sql = "select * from attachment where id=?;";
            stmt = conn.prepareStatement(sql);
            //给参数赋值
            stmt.setInt(1, 1);
            rs = stmt.executeQuery();
            //遍历结果集
            while (rs.next()) {
                //读取第2个字段
                InputStream is = rs.getBinaryStream(2);
                FileOutputStream fos = new FileOutputStream("D://nm.jpg");
                byte[] chs = new byte[1024];
                int len;
                while ((len=is.read(chs))!=-1) {
                    fos.write(chs, 0, len);
                }
                //释放资源
                fos.close();
                is.close();
            }
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //释放资源
            JDBCUtil.close(conn, stmt, rs);
        }
        
    }

    private static void write() {
        Connection conn = null;
        PreparedStatement stmt = null;
        try{
            conn = JDBCUtil.getConn();
            String sql = "insert into attachment values(?,?);";
            //预编译sql
            stmt = conn.prepareStatement(sql);
            //给sql参数赋值
            stmt.setInt(1, 2);
            //数据库默认要求，写入文件的大小是1m，如果存入数据库的文件大于这个容量就会抛出异常
            //com.mysql.jdbc.PacketTooBigException
            //max_allowed_packet
            stmt.setBlob(2, new FileInputStream("D://abc.mp3"));
            //发送参数并执行sql
            int count = stmt.executeUpdate();
            System.out.println(count);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //释放资源
            JDBCUtil.close(conn, stmt, null);
        }
    }

数据库事务

所谓事物，它是一个操作序列，这些操作要么都执行，要么都不执行，它是一个不可分割的工作单位。

mysql事务操作指令

set autocommit =0 / 1; 设置是否自动提交事务

1： 表示自动提交事务，每执行一条sql语句，自动提交事务。

0： 表示关闭自动提交事务。

commit;           提交事务，一旦提交事务不能回滚

rollback;           回滚事务。回滚到事务的起始点。

JDBC事务操作指令

Connection.setAutoCommit(false)  开启事务

Connection.commit();  成功执行，最后提交事务

Connection.rollback();  一旦遇到错误，回滚事务

    public static void main(String[] args) {
        Connection conn  =null;
        PreparedStatement stmt = null;
        //扣除james账户余额2000元
        String delSql = "update account set balance=balance-2000 where name='张三';";
        String addSql = "update account set balance=balance+2000 where name='李四';";
        
        try{
            conn = JDBCUtil.getConn();
            //开启事务
            conn.setAutoCommit(false);//将自动提交设置为手动提交
            
            stmt = conn.prepareStatement(delSql);
            //执行sql语句
            stmt.executeUpdate();
            
            //int i = 1/0;//假设在这里抛出了一个异常
            
            //下面给韦德账户增加钱的操作还会执行吗？
            stmt  =conn.prepareStatement(addSql);
            stmt.executeUpdate();
            //手动提交
            conn.commit();
            System.out.println("转账成功");    
        }catch(Exception e){
            e.printStackTrace();
            //回滚
            try {
                conn.rollback();
            } catch (SQLException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        }finally{
            //释放资源
            JDBCUtil.close(conn, stmt, null);
        }
        
        
    }

 事物的四大特性

●   Atomic（原子性）：事务中包含的操作被看做一个逻辑单元，这个逻辑单元中的操作要么全部成功，要么全部失败。

●   Consistency（一致性）：只有合法的数据可以被写入数据库，否则事务应该将其回滚到最初状态。

●   Isolation（隔离性）：事务允许多个用户对同一个数据进行并发访问，而不破坏数据的正确性和完整性。同时，并行事务的修改必须与其他并行事务的修改相互独立。

●   Durability（持久性）：事务结束后，事务处理的结果必须能够得到固化