Java 数据库编程3---处理大数据对象

- 日理万妓 2022-05-21 13:36 167阅读 0赞

大对象处理主要指的是`CLDB`和`BLOB`两种类型的字段。**在`CLOB`中可以存储海量`文字`**，例如一部《西游记》，《三国演义》等；**在`BLOB`中可以`存储二进制`数据**，如图片，视屏等。如果在程序用要想处理这样的大对象操作，则必须使用`PreparedStatement`完成，所用的内容要通过IO流的方式从大文本字段中保存和读取。  
`PrepareStatement`提供如下表的方法，专门用于写入大对象数据。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>void setAsciiStream(int parameterIndex, InputStream x, int length)</code></td> 
   <td>将制定的输入流，写入数据库的文本字段CLOB</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>void setBinaryStream(int parameterIndex, InputStream x, int length)</code></td> 
   <td>将二进制的输入流数据，写入到二进制字段BLOB中。</td> 
  </tr> 
 </tbody> 
</table>

大对象写入到数据库中后，在查询时就需要使用`ResultSet`将其读取出来。在`ResultSet`中提供了如下表所以的几个方法，可以用于读出大对象数据。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>InputStream **getAsciiStream**(int columnIndex)</code></td> 
   <td>根据<strong>列的编号</strong>返回大对象的文本输入流</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>InputStream **getAsciiStream**(String columnLabel)</code></td> 
   <td>根据列的名称返回大对象的文本输入流</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>Clob getClob(int columnIndex)</code></td> 
   <td>根据列的编号返回CLOB数据</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>Clob getClob(String columnLabel)</code></td> 
   <td>根据列的名称返回CLOB数据</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>InputStream getBinaryStream(int columnIndex)</code></td> 
   <td>根据列的编号返回二进制数据的输入流</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><code>InputStream getBinaryStream(String columnLabel)</code></td> 
   <td>根据列的名称返回二进制数据的输入流</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><code>Blob getBlob(int columnIndex)</code></td> 
   <td>根据列的编号返回Blob数据</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><code>Blob getBlob(String columnLabel)</code></td> 
   <td>根据列的名称返回BLOB数据的编号</td> 
  </tr> 
 </tbody> 
</table>

以上方法实际上分为两组,CLOB和AsciiStream一般都返回大文本，而Blob和BinaryStream一般都返回二进制数据。下面分别来看这些方法的操作。

## 处理CLOB数据 ##

CLOB表示大文本数据，在MySQL中提供了longtext表示大文本数据，此字段最大保存数据量为4GB.  
下面建立新的表testclob，来测试，SQL脚本如下

DROP TABLE IF EXISTS `testclob`;
    CREATE TABLE `testclob` ( `id` varchar(20) NOT NULL, `name` varchar(40) DEFAULT NULL, `sex` varchar(4) DEFAULT NULL, `text` longtext, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=gbk;

下面行`testclob`表中插入数据，对于区中text字段的内容，这里写入当前的java文件：`".\\src\\my.\\clobtest\\ClobDemo01.java"`，项目结构如下图。  
![目录结构][70]  
**实例:写入大文本数据**

package my.clobtest;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    public class ClobDemo01 { 
        // 数据库驱动
        public static final String driver = "com.mysql.jdbc.Driver";
        // 设置url: 协议名:子协议名:数据库地址(ip地址:端口号/数据库名)
        public static final String url = "jdbc:mysql://localhost:3306/usersinfo";
        // 设置用户名
        public static final String user = "root";
        // 设置密码
        public static final String password = "root";
        public static void main(String[] args) throws ClassNotFoundException, SQLException, FileNotFoundException
        {
            //数据库连接引用
            Connection con=null;
            //预编译操作引用
            PreparedStatement pstmt=null;
            //加载数据库驱动
            Class.forName(driver);
            //获取数据库连接对象
            con=DriverManager.getConnection(url,user,password);
            //设置testclob中的字段
            String id="B1000";
            String name="小赵";
            String sex="男";
            //获取当前java文件的输入流
            InputStream in=new FileInputStream(new File(".\\src\\my.\\clobtest\\ClobDemo01.java"));
    
    
    // id,name,sex,text
            //SQL语句
            String sql="insert into testclob(id,name,sex,text)"
                    +" values(?,?,?,?)";
            //实例化数据库预编译操作对象
            pstmt=con.prepareStatement(sql);
            //设置第一个占位符的内容
            pstmt.setString(1, id);
            //设置第二个占位符的内容
            pstmt.setString(2, name);
            //设置第三个占位符的内容
            pstmt.setString(3, sex);
            //设置之后一个占位符的内容
            pstmt.setAsciiStream(4, in);
            //执行插入sql语句
            String toString=pstmt.toString();
            System.out.println("mysql>"+toString.substring(toString.lastIndexOf(":")+1).trim());
            pstmt.executeUpdate();
            //关闭操作
            pstmt.close();
            //关闭数据库连接
            con.close();
        }
    
    }

运行结果：

*  控制台输出：

mysql>insert into testclob(id,name,sex,text) values('B1000','小赵','男',** STREAM DATA **)

*  **testclob表中的数据**  
    ![test表中的数据][test]  
    因为内容保存在文件中，所以使用FileInputStream类将文本文件读取到程序中，再通过PrepareStatement对象将其写入到对应的大文本字段中。  
    写入完成后，可以直接使用ResultSet将其读取出来，因为写入时是按照输入流的方式写入的，所以此时也需要按照输入流的方式出去出来。  
    **实例：从数据库中读取大文本字段**

import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Scanner;
    
    public class ClobDemo02 { 
        //设置数据库驱动
        public static final String driver="com.mysql.jdbc.Driver";
        //设置url
        public static final String url="jdbc:mysql://localhost:3306/usersinfo";
        //设置用户名
        public static final String user="root";
        //设置密码
        public static final String password="root";
        public static void main(String[] args) throws ClassNotFoundException, SQLException
        {
            //设置数据库连接引用
            Connection con=null;
            //设置数据库预编译操作
            PreparedStatement pstmt=null;
            //设置结果集引用
            ResultSet rs=null;
            //加载数据库驱动
            Class.forName(driver);//ClassNotFoundException
            //建立数据库连接 SQLException
            con=DriverManager.getConnection(url,user,password);
            //SQL语句
            String sql="select id,name,sex,text from testclob"+
                        " where id = ?";
            //实例化预编译操作对象
            pstmt=con.prepareStatement(sql);
    
            String idmode="B1000";
            //设置第一个占位符
            pstmt.setString(1, idmode);
            //执行数据库查询操作
            String toString=pstmt.toString();
            System.out.println("mysql>"+toString.substring(toString.lastIndexOf(":")+1).trim());
    
            rs=pstmt.executeQuery();
            //遍历结果集
            while(rs.next())
            {
                System.out.print("学号:"+rs.getString(1));
                System.out.print(",姓名:"+rs.getString(2));
                System.out.print(",性别:"+rs.getString(3));
                System.out.println(",文件：");
                InputStream in=rs.getAsciiStream(4);
                Scanner scanner=new Scanner(in);
                scanner.useDelimiter("\r\n");
                while(scanner.hasNext())
                {
                    System.out.println(scanner.next());
                }
                System.out.println();
            }
            //关闭操作
            pstmt.close();
            //关闭连接
            con.close();
        }
    }

运行部分结果：

mysql>select id,name,sex,text from testclob where id = 'B1000'
    学号:B1000,姓名:小赵,性别:男,文件：
    package my.clobtest;
    ......略
    public class ClobDemo01 { 
    ......略
    }

在以上程序中，为了操作方便，使用了Scanner类接收全部的输入内容。由于在文本保存时存在换行，所以使用”\\r\\n”作为分隔符。再通过循环的方式不断的把内容取出并打印到控制台上。  
以上的做法是将大文本内容直接通过ResultSet读取出来，当然也可以使用`ResultSet`的`getClob()`方法，将全部的内容变为Clob对象的内容。**直接使用Clob可以方便的取得大文本数据**，也可以对这些文本数据进行一些简单的操作，如截取指定长度的文本等。Clob的常用方法如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>InputStream getAsciiStream()</td> 
   <td>返回输入流对象</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>String getSubString(long pos, int length)</td> 
   <td>从Clob中取得指定范围的字符串</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>long length()</td> 
   <td>返回Clob中的字符数量</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>void truncate(long len)</td> 
   <td>截取指定长度的大文本</td> 
  </tr> 
 </tbody> 
</table>

**实例：使用Clob类来读取内容**

package my.clobtest;
    
    import java.sql.Clob;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class ClobDemo03 { 
        //设置数据库驱动
        public static final String driver="com.mysql.jdbc.Driver";
        //设置url
        public static final String url="jdbc:mysql://localhost:3306/usersinfo";
        //设置数据库用户名
        public static final String user="root";
        //设置密码
        public static final String password="root";
        public static void main(String[] args) throws ClassNotFoundException, SQLException 
        {
            //数据库连接引用
            Connection connection=null;
            //数据库操作引用
            PreparedStatement pstmt=null;
            //查询结果集引用
            ResultSet rs=null;
    
            //SQL语句
            String sql="select id,name,sex,text from testclob"
                    + " where id=?";
            //加载数据库驱动
            Class.forName(driver);
            //取得数据库连接
            connection=DriverManager.getConnection(url,user,password);
            //实例化数据库操作
            pstmt=connection.prepareStatement(sql);
            pstmt.setString(1, "B1000");
            //输出编译好的SQL语句
            String toString=pstmt.toString();
            System.out.println("mysql>"+toString.substring(toString.lastIndexOf(":")+1).trim());
            //执行查询SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //遍历结果集
            while(rs.next())
            {
                System.out.print("学号:"+rs.getString(1));
                System.out.print(",姓名:"+rs.getString(2));
                System.out.print(",性别:"+rs.getString(3));
                System.out.print(",文件：");
                //取出大文件字段
                Clob clob=rs.getClob(4);
                //大对象字段转成字符串
                String text=clob.getSubString(1, (int)clob.length());
                System.out.print(text);
                System.out.println();
            }
            //关闭预处理操作
            pstmt.close();
            //关闭数据库连接
            connection.close();
        }
    
    }

**运行结果(部分)**

mysql>select id,name,sex,text from testclob where id='B1000'
    学号:B1000,姓名:小赵,性别:男,文件：package my.clobtest;
    
    import java.io.File;
    ......略
    public class ClobDemo01 { 
        // 数据库驱动
        public static final String driver = "com.mysql.jdbc.Driver";
    ......略
            //关闭操作
            pstmt.close();
            //关闭数据库连接
            con.close();
        }
    
    }

以上两个实例都能完成大对象的读取，当从代码上来看**，直接使用Clob类来操作，要比使用InputStream方便的多。**

## 处理BLOB数据 ##

BLOB的操作与CLOB相似，**只是BLOB专门用于存放二进制数据**，如图片，电影等，下面通过BLOB进行图片的保存于读取。在MySQL中使用**longblob**声明，**最高可以保存4GB大小的内容。**  
下面穿件一个新的表`testblob`来测试BLOB的操作，

DROP TABLE IF EXISTS `testblob`;
    CREATE TABLE `testblob` ( `id` varchar(20) NOT NULL, `name` varchar(20) DEFAULT NULL, `sex` varchar(4) DEFAULT NULL, `picture` longblob, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=gbk;

下面向表中插入数据，对于picture字段的内容使用下面的图片，该图片放在当前工程的路径下面。  
![使用的图片][70 1]  
图片在工程中的位置：  
![放在Java工程的路径中][Java]  
**实例：将图片写入到数据库中**

package my.blobtest;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    public class BlobDemo1 { 
        public static final String driver="com.mysql.jdbc.Driver";
        public static final String url="jdbc:mysql://localhost:3306/usersinfo";
        public static final String user="root";
        public static final String password="root";
        public static void main(String[] args) throws ClassNotFoundException, SQLException, FileNotFoundException
        {
            Connection con=null;
            PreparedStatement pstmt=null;
            String id="B1000";
            String name="小钱";
            String sex="男";
            InputStream picture=new FileInputStream(new File(".\\蓝精灵1.jpg"));
    
            String sql="insert into testblob(id,name,sex,picture) "
                    + "values(?,?,?,?)";
    
            //加载数据库驱动
            Class.forName(driver);
            //建立数据库连接
            con=DriverManager.getConnection(url,user,password);
            //实例化数据库操作对象
            pstmt=con.prepareStatement(sql);
            //设置占位符
            pstmt.setString(1, id);
            pstmt.setString(2, name);
            pstmt.setString(3, sex);
            //设置图片
            pstmt.setBinaryStream(4, picture);
            //打印编译好的SQL语句
            String toString=pstmt.toString();
            System.out.println("mysql>"+toString.substring(toString.lastIndexOf(":")+1).trim());
            //执行插入操作
            pstmt.executeUpdate();
            //关闭操作
            pstmt.close();
            //关闭连接
            con.close();
        }
    }

**运行结果：**

*  控制台输出：

mysql>insert into testblob(id,name,sex,picture) values('B1000','小钱','男',** STREAM DATA **)

*  testblob表中的数据  
    ![testclob表中的数据][testclob]

程序执行完毕后，图片的信息就以二进制的形式保存在数据表中，如果直接向数据库发出查询指令，则只能显示一些二进制代码，而图片无法显示。如下所示。

use usersinfo;
    select *from testblob;

运行结果：  
![查询结果][70 2]  
下面**直接使用ResultSet中的方法直接从数据库中读出所需要的图片**。因为是在命令行下运行程序的，所以读取出来的图片无法直接显示，这里把图片保存下来，然后在通过本机的图片查看软件打开，图片的保存路径为当前工程下的`.\蓝精灵读出的.jpg`  
**实例：从数据库中读出图片，并存储到当前工程下**

package my.blobtest;
    
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class BlobDemo2 { 
        public static final String driver = "com.mysql.jdbc.Driver";
        public static final String url = "jdbc:mysql://localhost:3306/usersinfo";
        public static final String user = "root";
        public static final String password = "root";
    
        public static void main(String[] args) throws ClassNotFoundException,SQLException, IOException
        {
            Connection con=null;
            PreparedStatement pstmt=null;
            ResultSet rs=null;
            String sql="select id,name,sex,picture from testblob "
                    + "where id=?";
            Class.forName(driver);
            con=DriverManager.getConnection(url,user,password);
            pstmt=con.prepareStatement(sql);
            pstmt.setString(1, "B1000");
            String toString=pstmt.toString();
            System.out.println("mysql>"+toString.substring(toString.lastIndexOf(":")+1).trim());
            rs=pstmt.executeQuery();
            while(rs.next())
            {
                System.out.print("学号:"+rs.getString(1));
                System.out.print(",姓名:"+rs.getString(2));
                System.out.print(",性别:"+rs.getString(3));
                System.out.println(",:.\\蓝精灵副本.jpg");
                InputStream in=null;
                //获取图片的输入流
                in=rs.getBinaryStream(4);
                BufferedOutputStream pictureout=new BufferedOutputStream(
                        new FileOutputStream(new File(".\\蓝精灵副本.jpg")));
                int size=0;
                //读入到缓冲中，然后写入本地文件
                while ((size=in.read())!=-1)
                {
                    pictureout.write(size);
                }
                in.close();
                pictureout.close();
            }
            //关闭操作
            pstmt.close();
            //关闭连接
            con.close();
        }
    }

**运行结果：**

*  控制台输出：

mysql>select id,name,sex,picture from testblob where id='B1000' 学号:B1000,姓名:小钱,性别:男,:.\蓝精灵副本.jpg

*  刷新当前工程可以看到图片：  
    ![下载好的图片][70 3]
 *  打开`蓝精灵副本.jpg`:  
    ![蓝精灵副本][70 4]  
    可以看到下载的图片和之前我们存储到数据库中的图片显示效果是一样的.

与大文本操作类似，在\*\*JDBC中也提供了专门的`Blob`类型，用于表示二进制数据。\*\*Blob类的常用方法如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>InputStream getBinaryStream()</td> 
   <td>取得Blob的输出流</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>byte[] getBytes(long pos, int length)</td> 
   <td>以字节数组的形式返回Blob字段中的内容，从pos位置开始，去length个字节返回</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>long length()</td> 
   <td>取出数据的长度</td> 
  </tr> 
 </tbody> 
</table>

下面直接使用Blob类完成Blob字段的操作，和之前一样还是讲图片下载到当前工程目录下。  
**实例：使用Blob读取数据库中的图片。**

package my.blobtest;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.sql.Blob;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class BlobDemo3 { 
        public static final String  driver="com.mysql.jdbc.Driver";
        public static final String url="jdbc:mysql://localhost:3306/usersinfo";
        public static final String user="root";
        public static final String password="root";
        public static void main(String[] args)throws ClassNotFoundException,SQLException,IOException
        {
            Connection con;
            PreparedStatement pstmt;
            ResultSet rs;
            String sql="select id,name,sex,picture from testblob "
                    + "where id=?";
    
            Class.forName(driver);
            con=DriverManager.getConnection(url,user,password);
            pstmt=con.prepareStatement(sql);
            pstmt.setString(1, "B1000");
            String toString=pstmt.toString();
            System.out.println("mysql>"+toString.substring(toString.lastIndexOf(":")+1).trim());
            rs=pstmt.executeQuery();
            while(rs.next())
            {
                System.out.print("学号:"+rs.getString(1));
                System.out.print(",姓名:"+rs.getString(2));
                System.out.print(",性别:"+rs.getString(3));
                //取出Blob字段
                Blob blob=rs.getBlob(4);
                File outFile=new File(".//蓝精灵副本2.jpg");
                FileOutputStream pictureOut=new FileOutputStream(outFile);
                //写入jpg文件中
                pictureOut.write(blob.getBytes(1, (int)blob.length()));
                System.out.print(",图片以及下载到:"+outFile.getAbsolutePath());
                //关闭输出流
                pictureOut.close();
            }
            //关闭操作
            pstmt.close();
            //关闭连接
            con.close();
        }
    }

**运行结果：**

*  控制台输出：

mysql>select id,name,sex,picture from testblob where id='B1000'
    学号:B1000,姓名:小钱,性别:男,图片以及下载到:C:\Users\lan\Desktop\学习8\安装软件\代码\MyTest\.\蓝精灵副本2.jpg

*  当前工程目录下的文件：  
    ![下载新的文件][70 5]
 *  查看该图片：  
    ![使用Blob类下载的图片][Blob]

要注意的是，**虽然JDBC中提供了大对象的操作的支持，但是如果内容太大(比如：电影)，则不建议使用大对象进行保存。**此时，可以`通过做映射路径的方式保存具体的大文件的路径信息`，**即在数据库中使用一个varchar的普通字段保存一个大文件的绝对路径(**如果文件在本地硬盘上的话)。

[70]: /images/20220521/226b9d921bc3472c81fd33c35aeeac3f.png
[test]: /images/20220521/196a4a916f9c4cc4a10390f800a8b013.png
[70 1]: /images/20220521/7d243ea315a2421ebf379f251c311f76.png
[Java]: /images/20220521/c50c58c5d00942e2bb2babf4810c5ce5.png
[testclob]: /images/20220521/bbcac1e5899c40f3811afe0be92aace5.png
[70 2]: /images/20220521/58b9e1a481f54c7c9a819d79cc166bda.png
[70 3]: /images/20220521/b3ca2b524a3a43f8bab3137f501cc743.png
[70 4]: /images/20220521/c11d6d7abdb34205a01109866fd7447a.png
[70 5]: /images/20220521/2c2d2dadde504ed9b8b21f5a06701bcb.png
[Blob]: /images/20220521/0f5976136a6d4699b49c1b40cacee4f2.png