Java进阶学习第八天（JDBC）

一、JDBC入门

1、之前操作数据
① 通过mysql的客户端工具，登录数据库服务器 （mysql -u root -p 密码）
② 编写sql语句
③ 发送sql语句到数据库服务器执行

2、什么是JDBC？
使用Java代码（程序）发送SQL语句的技术，就是JDBC技术！
它是sun公司设计的一套通用的Java语言操作不同数据库的接口！

3、使用JDBC发送SQL前提：登录数据库服务器（连接数据库服务器）
① 数据库的IP地址
② 端口
③ 数据库用户名
④ 密码

/**
 * jdbc连接数据库
 */
public class Demo8.1 {
    //连接数据库的URL
    private String url = "jdbc:mysql://localhost:3306/myTest";
    // jdbc协议:数据库子协议:主机:端口/连接的数据库
    private String user = "root";//用户名
    private String password = "root";//密码

    /**
     * 第一种方法
     * @throws Exception
     */
    @Test
    public void test1() throws Exception{
        //1.创建驱动程序类对象
        Driver driver = new com.mysql.jdbc.Driver(); //新版本
        //Driver driver = new org.gjt.mm.mysql.Driver(); //旧版本
        //设置用户名和密码
        Properties props = new Properties();
        props.setProperty("user", user);
        props.setProperty("password", password);
        //2.连接数据库，返回连接对象
        Connection conn = driver.connect(url, props);
        System.out.println(conn);
    }

    /**
     * 第二种方法：使用驱动管理器类连接数据库(注册了两次，没必要)
     * @throws Exception
     */
    @Test
    public void test2() throws Exception{
        Driver driver = new com.mysql.jdbc.Driver();
        //Driver driver2 = new com.oracle.jdbc.Driver();
        //1.注册驱动程序(可以注册多个驱动程序)
        DriverManager.registerDriver(driver);
        //DriverManager.registerDriver(driver2);
        //2.连接到具体的数据库
        Connection conn = DriverManager.getConnection(url, user, password);
        System.out.println(conn);
    }

    /**
     * （推荐使用这种方式连接数据库）
     *  第三种方法：推荐使用加载驱动程序类来注册驱动程序 
     * @throws Exception
     */
    @Test
    public void test3() throws Exception{
        //1.通过得到字节码对象的方式加载静态代码块，从而注册驱动程序
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接到具体的数据库
        Connection conn = DriverManager.getConnection(url, user, password);
        System.out.println(conn);   
    }
}

4、JDBC的URL＝协议名＋子协议名＋数据源名
① 协议名总是“jdbc”。
② 子协议名由JDBC驱动程序的编写者决定。
③ 数据源名也可能包含用户与口令等信息；这些信息也可单独提供。
④ 几种常见的数据库连接

数据库	连接
oracle
驱动	oracle.jdbc.driver.OracleDriver
URL	jdbc:oracle:thin:@machine_name:port:dbname
注	machine_name：数据库所在的机器的名称；port：端口号，默认是1521
mysql
驱动	com.mysql.jdbc.Driver
URL	jdbc:mysql://machine_name:port/dbname
注	machine_name：数据库所在的机器的名称；port：端口号，默认3306
SQL Server
驱动	com.microsoft.jdbc.sqlserver.SQLServerDriver
URL	jdbc:microsoft:sqlserver://<machine_name><:port>;DatabaseName=<dbname>
注	machine_name：数据库所在的机器的名称；port：端口号，默认是1433
DB2
驱动	com.ibm.db2.jdbc.app.DB2Driver
URL	jdbc:db2://<machine_name><:port>/dbname
注	machine_name：数据库所在的机器的名称；port：端口号，默认是5000

5、JDBC接口核心的API
java.sql.*（JDK2.0之前） 和 javax.sql.*（JDK2.0之后）

① Driver接口：表示java驱动程序接口，所有的具体的数据库厂商要来实现此接口。
◆ connect(url, properties)：连接数据库的方法。
◇ url: 连接数据库的URL
◇ URL语法：jdbc协议:数据库子协议://主机:端口/数据库
◇ user：数据库的用户名
◇ password：数据库用户密码
② DriverManager类：驱动管理器类，用于管理所有注册的驱动程序
◆ registerDriver(driver)：注册驱动类对象
◆ Connection getConnection(url,user,password)：获取连接对象
③ Connection接口： 表示java程序和数据库的连接对象。
◆ Statement createStatement()：创建Statement对象
◆ PreparedStatement prepareStatement(String sql)：创建PreparedStatement对象
◆ CallableStatement prepareCall(String sql)：创建CallableStatement对象

④ Statement接口：用于执行静态的sql语句
◆ int executeUpdate(String sql)：执行静态的更新sql语句（DDL，DML）
◆ ResultSet executeQuery(String sql)：执行的静态的查询sql语句（DQL）
⑤ PreparedStatement接口：用于执行预编译sql语句
◆ int executeUpdate() ：执行预编译的更新sql语句（DDL，DML）
◆ ResultSet executeQuery()：执行预编译的查询sql语句（DQL）
⑥ CallableStatement接口：用于执行存储过程的sql语句（call xxx）
◆ ResultSet executeQuery()：调用存储过程的方法

⑦ ResultSet接口：用于封装查询出来的数据
◆ boolean next()：将光标移动到下一行
◆ getXX()：获取列的值

二、使用Statement执行sql语句

1、执行DDL语句

public class Demo8.2 {
    //private String url = "jdbc:mysql://localhost:3306/myTest";
    private String url = "jdbc:mysql:///myTest";
    private String user = "root";
    private String password = "root";
    @Test
    public void test1(){
        Statement stmt = null;
        Connection conn = null;
        try {
            //1.驱动注册程序
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.getConnection(url, user, password);
            //3.创建Statement
            stmt = conn.createStatement();
            //4.准备sql
            //添加一张student表
            String sql = "CREATE TABLE student(id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(20),gender VARCHAR(2))";
            //5.发送sql语句，执行sql语句,得到返回结果
            int count = stmt.executeUpdate(sql);
            //6.输出
            System.out.println("影响了"+count+"行！");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally{
            //7.关闭连接(顺序:后打开的先关闭)
            if(stmt!=null)
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            if(conn!=null)
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
        }
    }
}

2、jdbc工具类JdbcUtil（自己设计）

public class JdbcUtil {
    private static String url = "jdbc:mysql://localhost:3306/myTest";
    private static String user = "root";
    private static String password = "root";
    /**
     * 静态代码块中（只加载一次）
     */
    static{
        try {
            //注册驱动程序
            Class.forName("com.mysql.jdbc.Driver");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("驱程程序注册出错");
        }
    }
    /**
     * 抽取获取连接对象的方法
     */
    public static Connection getConnection(){
        try {
            Connection conn = DriverManager.getConnection(url, user, password);
            return conn;
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    /**
     * 释放资源的方法
     */
    public static void close(Connection conn,Statement stmt){
        if(stmt!=null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
    }
    public static void close(Connection conn,Statement stmt,ResultSet rs){
        if(rs!=null)
            try {
                rs.close();
            } catch (SQLException e1) {
                e1.printStackTrace();
                throw new RuntimeException(e1);
            }
        if(stmt!=null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
    }
}

3、执行DML语句

扫描二维码关注公众号，回复： 3212238 查看本文章

public class Demo8.3{
    private String url = "jdbc:mysql://localhost:3306/myTest";
    private String user = "root";
    private String password = "root";
    /**
     * 增加
     */
    @Test
    public void testInsert(){
        Connection conn = null;
        Statement stmt = null;
        try {
            /*//1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.getConnection(url, user, password);*/
            //通过工具类获取连接对象
            conn = JdbcUtil.getConnection();
            //3.创建Statement对象
            stmt = conn.createStatement();          
            //4.sql语句
            String sql = "INSERT INTO student(NAME,gender) VALUES('李四','女')";           
            //5.执行sql
            int count = stmt.executeUpdate(sql);        
            System.out.println("影响了"+count+"行");            
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally{
            //关闭资源
            /*if(stmt!=null)
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            if(conn!=null)
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }*/
            JdbcUtil.close(conn, stmt);
        }
    }

    /**
     * 修改
     */
    @Test
    public void testUpdate(){
        Connection conn = null;
        Statement stmt = null;
        //模拟用户输入
        String name = "陈六";
        int id = 3;
        try {
            /*//1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.getConnection(url, user, password);*/
            //通过工具类获取连接对象
            conn = JdbcUtil.getConnection();
            //3.创建Statement对象
            stmt = conn.createStatement();  
            //4.sql语句
            String sql = "UPDATE student SET NAME='"+name+"' WHERE id="+id+"";  
            System.out.println(sql);
            //5.执行sql
            int count = stmt.executeUpdate(sql);        
            System.out.println("影响了"+count+"行");    
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally{
            //关闭资源
            /*if(stmt!=null)
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            if(conn!=null)
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }*/
            JdbcUtil.close(conn, stmt);
        }
    }

    /**
     * 删除
     */
    @Test
    public void testDelete(){
        Connection conn = null;
        Statement stmt = null;
        //模拟用户输入
        int id = 3;
        try {
            /*//1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.getConnection(url, user, password);*/
            //通过工具类获取连接对象
            conn = JdbcUtil.getConnection();
            //3.创建Statement对象
            stmt = conn.createStatement();  
            //4.sql语句
            String sql = "DELETE FROM student WHERE id="+id+"";
            System.out.println(sql);
            //5.执行sql
            int count = stmt.executeUpdate(sql);
            System.out.println("影响了"+count+"行");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally{
            //关闭资源
            /*if(stmt!=null)
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            if(conn!=null)
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }*/
            JdbcUtil.close(conn, stmt);
        }
    }
}

4、执行DQL语句

SQL类型	Jdbc对应方法	返回类型
BIT(1) bit(n)	getBoolean getBytes()	Boolean byte[]
TINYINT	getByte()	Byte
SMALLINT	getShort()	Short
Int	getInt()	Int
BIGINT	getLong()	Long
CHAR,VARCHAR,LONGVARCHAR	getString()	String
Text(clob) Blob	getClob getBlob()	Clob Blob
DATE	getDate()	java.sql.Date
TIME	getTime()	java.sql.Time
TIMESTAMP	getTimestamp()	java.sql.Timestamp

public class Demo8.4{
    @Test
    public void test1(){
        Connection conn = null;
        Statement stmt = null;
        try{
            //获取连接
            conn = JdbcUtil.getConnection();
            //创建Statement
            stmt = conn.createStatement();
            //准备sql
            String sql = "SELECT * FROM student";
            //执行sql
            ResultSet rs = stmt.executeQuery(sql);
            //移动光标
            /*boolean flag = rs.next();
            flag = rs.next();
            flag = rs.next();
            if(flag){
                //取出列值
                //索引
                int id = rs.getInt(1);
                String name = rs.getString(2);
                String gender = rs.getString(3);
                System.out.println(id+","+name+","+gender);
                //列名称
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String gender = rs.getString("gender");
                System.out.println(id+","+name+","+gender);
            }*/
            //遍历结果
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String gender = rs.getString("gender");
                System.out.println(id+","+name+","+gender);
            }   
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException(e);
        }finally{
            JdbcUtil.close(conn, stmt);
        }
    }
}

三、使用PreparedStatement执行sql语句

1、数据库操作

public class Demo8.5{
    /**
     * 增加
     */
    @Test
    public void testInsert() {
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            //1.获取连接
            conn = JdbcUtil.getConnection();    
            //2.准备预编译的sql
            String sql = "INSERT INTO student(NAME,gender) VALUES(?,?)"; //?表示一个参数的占位符
            //3.执行预编译sql语句(检查语法)
            stmt = conn.prepareStatement(sql);
            //4.设置参数值
            stmt.setString(1, "李四");
            stmt.setString(2, "男"); 
            //5.发送参数，执行sql
            int count = stmt.executeUpdate();   
            System.out.println("影响了"+count+"行");    
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            JdbcUtil.close(conn, stmt);
        }
    }

    /**
     * 修改
     */
    @Test
    public void testUpdate() {
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            //1.获取连接
            conn = JdbcUtil.getConnection();            
            //2.准备预编译的sql
            String sql = "UPDATE student SET NAME=? WHERE id=?"; //?表示一个参数的占位符      
            //3.执行预编译sql语句(检查语法)
            stmt = conn.prepareStatement(sql);
            //4.设置参数值
            stmt.setString(1, "王五");
            stmt.setInt(2, 9);
            //5.发送参数，执行sql
            int count = stmt.executeUpdate();
            System.out.println("影响了"+count+"行");    
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            JdbcUtil.close(conn, stmt);
        }
    }

    /**
     * 删除
     */
    @Test
    public void testDelete() {
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            //1.获取连接
            conn = JdbcUtil.getConnection();
            //2.准备预编译的sql
            String sql = "DELETE FROM student WHERE id=?"; //?表示一个参数的占位符        
            //3.执行预编译sql语句(检查语法)
            stmt = conn.prepareStatement(sql);
            //4.设置参数值
            stmt.setInt(1, 9);
            //5.发送参数，执行sql
            int count = stmt.executeUpdate();
            System.out.println("影响了"+count+"行");    
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            JdbcUtil.close(conn, stmt);
        }
    }

    /**
     * 查询
     */
    @Test
    public void testQuery() {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            //1.获取连接
            conn = JdbcUtil.getConnection();
            //2.准备预编译的sql
            String sql = "SELECT * FROM student"; 
            //3.预编译
            stmt = conn.prepareStatement(sql);
            //4.执行sql
            rs = stmt.executeQuery();
            //5.遍历rs
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String gender = rs.getString("gender");
                System.out.println(id+","+name+","+gender);
            }   
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            //关闭资源
            JdbcUtil.close(conn,stmt,rs);
        }
    }
}

2、PreparedStatement和Statment区别
① 语法不同：PreparedStatement可以使用预编译的sql，而Statment只能使用静态的sql
② 效率不同： PreparedStatement可以使用sql缓存区，效率比Statment高
③ 安全性不同： PreparedStatement可以有效防止sql注入，而Statment不能防止sql注入。

推荐使用：PreparedStatement

3、支持sql缓冲区的数据库：oracle、sql server
不支持sql缓冲区的数据库：mysql

四、CallableStatement调用存储过程

public class Demo8.6{
    /**
     * 调用带有输入参数的存储过程
     * CALL pro_findById(4);
     */
    @Test
    public void test1(){
        Connection conn = null;
        CallableStatement stmt = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();    
            //准备sql
            String sql = "CALL pro_findById(?)"; //可以执行预编译的sql  
            //预编译
            stmt = conn.prepareCall(sql);   
            //设置输入参数
            stmt.setInt(1, 4);
            //发送参数
            rs = stmt.executeQuery(); //注意： 所有调用存储过程的sql语句都是使用executeQuery方法执行！
            //遍历结果
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String gender = rs.getString("gender");
                System.out.println(id+","+name+","+gender);
            }   
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            JdbcUtil.close(conn, stmt ,rs);
        }
    }

    /**
     * 执行带有输出参数的存储过程
     * CALL pro_findById2(5,@NAME);
     */
    @Test
    public void test2(){
        Connection conn = null;
        CallableStatement stmt = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            //准备sql
            String sql = "CALL pro_findById2(?,?)"; //第一个？是输入参数，第二个？是输出参数
            //预编译
            stmt = conn.prepareCall(sql);
            //设置输入参数
            stmt.setInt(1, 6);
            //设置输出参数(注册输出参数)
            stmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            //发送参数，执行
            stmt.executeQuery(); //结果不是返回到结果集中，而是返回到输出参数中
            //得到输出参数的值
            //索引值： 预编译sql中的输出参数的位置
            String result = stmt.getString(2); //getXX方法专门用于获取存储过程中的输出参数
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            JdbcUtil.close(conn, stmt ,rs);
        }
    }
}

五、类路径读取JdbcUtil的配置文件

1、db.properties文件

url=jdbc:mysql://localhost:3306/myTest
user=root
password=root
driverClass=com.mysql.jdbc.Driver

2、修改过的jdbc工具类JdbcUtil

public class JdbcUtil {
    private static String url = null;
    private static String user = null;
    private static String password = null;
    private static String driverClass = null;
    /**
     * 静态代码块中（只加载一次）
     */
    static{
        try {
            //读取db.properties文件
            Properties props = new Properties();

            /**
             *  .代表java命令运行的目录
             *  在java项目下，.代表java命令的运行目录从项目的根目录开始
             *  在web项目下，.代表java命令的而运行目录从tomcat/bin目录开始
             *  所以在web项目下不能使用点.
             */
            //FileInputStream in = new FileInputStream("./src/db.properties");
            /**
             * 使用类路径的读取方式
             *  / : 斜杠表示classpath的根目录
             *  在java项目下，classpath的根目录从bin目录开始
             *  在web项目下，classpath的根目录从WEB-INF/classes目录开始
             */
            InputStream in = JdbcUtil.class.getResourceAsStream("/db.properties");

            //加载文件
            props.load(in);
            //读取信息
            url = props.getProperty("url");
            user = props.getProperty("user");
            password = props.getProperty("password");
            driverClass = props.getProperty("driverClass");

            //注册驱动程序
            Class.forName(driverClass);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("驱程程序注册出错");
        }
    }
    /**
     * 抽取获取连接对象的方法
     */
    public static Connection getConnection(){
        try {
            Connection conn = DriverManager.getConnection(url, user, password);
            return conn;
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    /**
     * 释放资源的方法
     */
    public static void close(Connection conn,Statement stmt){
        if(stmt!=null){
            try {
                stmt.close();//快速异常捕获：Alt+Shift+Z
                stmt=null;//建议垃圾回收器回收资源
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
        if(conn!=null){
            try {
                conn.close();
                conn=null;
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
    }
    public static void close(Connection conn,Statement stmt,ResultSet rs){
        if(rs!=null)
            try {
                rs.close();
                rs = null;
            } catch (SQLException e1) {
                e1.printStackTrace();
                throw new RuntimeException(e1);
            }
        if(stmt!=null){
            try {
                stmt.close();
                stmt= null;
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
        if(conn!=null){
            try {
                conn.close();
                conn= null;
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
    }
}

六、Jdbc中大文本类型的处理

1、Oracle数据库中大文本数据类型
① Clob：长文本类型 （MySQL中不支持，使用的是text）
② Blob：二进制类型

2、MySQL数据库中大文本数据类型
① Text 长文本类型
② Blob 二进制类型

3、需求： jdbc中操作长文本数据。

CREATE TABLE test(
     id INT PRIMARY KEY AUTO_INCREMENT,
     content LONGTEXT,
     img LONGBLOB
);

① Text

public class App_text {
    // 全局参数
    private Connection con;
    private Statement stmt;
    private PreparedStatement pstmt;
    private ResultSet rs;

    @Test
    // 1. 保存大文本数据类型(写longtext)
    public void testSaveText() {
        String sql = "insert into test(content) values(?)";
        try {
            // 连接
            con = JdbcUtil.getConnection();
            // pstmt 对象
            pstmt = con.prepareStatement(sql);
            // 设置参数
            // 先获取文件路径
            String path = App_text.class.getResource("tips.txt").getPath();
            FileReader reader = new FileReader(new File(path));
            pstmt.setCharacterStream(1, reader);
            // 执行sql
            pstmt.executeUpdate();
            // 关闭
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeAll(con, pstmt, null);
        }
    }

    @Test
    // 2. 读取大文本数据类型   ( 读longtext)
    public void testGetAsText() {
        String sql = "select * from  test;";
        try {
            // 连接
            con = JdbcUtil.getConnection();
            // pstmt 对象
            pstmt = con.prepareStatement(sql);
            // 读取
            rs = pstmt.executeQuery();
            if (rs.next()) {
                // 获取长文本数据, 方式1:
                //Reader r = rs.getCharacterStream("content");
                // 获取长文本数据, 方式2:
                System.out.print(rs.getString("content"));
            }   
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeAll(con, pstmt, null);
        }
    }
}

② blob

public class App_blob {
    // 全局参数
    private Connection con;
    private Statement stmt;
    private PreparedStatement pstmt;
    private ResultSet rs;

    @Test
    // 1. 二进制数据类型 (写longblob)
    public void testSaveText() {
        String sql = "insert into test(img) values(?)";
        try {
            // 连接
            con = JdbcUtil.getConnection();
            // pstmt 对象
            pstmt = con.prepareStatement(sql);
            // 获取图片流
            InputStream in = App_text.class.getResourceAsStream("7.jpg");
            pstmt.setBinaryStream(1, in);
            // 执行保存图片
            pstmt.execute();
            // 关闭
            in.close(); 
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeAll(con, pstmt, null);
        }
    }

    @Test
    // 2. 读取大文本数据类型 (读longblob)
    public void testGetAsText() {
        String sql = "select img from  test where id=2;";
        try {
            // 连接
            con = JdbcUtil.getConnection();
            // pstmt 对象
            pstmt = con.prepareStatement(sql);
            // 读取
            rs = pstmt.executeQuery();
            if (rs.next()) {
                // 获取图片流
                InputStream in = rs.getBinaryStream("img");
                // 图片输出流
                FileOutputStream out = new FileOutputStream(new File("c://1.jpg"));
                int len = -1;
                byte b[] = new byte[1024];
                while ((len = in.read(b)) != -1) {
                    out.write(b, 0, len);
                }
                // 关闭
                out.close();
                in.close();
            }   
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeAll(con, pstmt, null);
        }
    }
}