1. package book.database;  
    2.  
  2.  
    3.  
  3. import java.io.File;  
    4.  
  4. import java.io.FileInputStream;  
    5.  
  5. import java.io.FileOutputStream;  
    6.  
  6. import java.io.IOException;  
    7.  
  7. import java.io.InputStream;  
    8.  
  8. import java.sql.Blob;  
    9.  
  9. import java.sql.Connection;  
    10.  
  10. import java.sql.PreparedStatement;  
    11.  
  11. import java.sql.ResultSet;  
    12.  
  12. import java.sql.SQLException;  
    13.  
  13. import java.sql.Statement;  
    14.  
  14.  
    15.  
  15. /**  
    16.  
  16.  * 存取BLOB数据到数据库。  
    17.  
  17.  */ 
    18.  
  18. public class BlobData {  
    19.  
  19.     /**  
    20.  
  20.      * 写Blob数据到数据库  
    21.  
  21.      * @param con     
    22.  
  22.      * @param infilePath    保存到数据库的文件     
    23.  
  23.      */ 
    24.  
  24.     public static void writeBlob(Connection con, String infilePath){  
    25.  
  25.         FileInputStream fis = null;  
    26.  
  26.         PreparedStatement psm = null;  
    27.  
  27.         try {  
    28.  
  28.             //打开输入文件  
    29.  
  29.             File file = new File(infilePath);  
    30.  
  30.             fis = new FileInputStream(file);  
    31.  
  31.             psm = con.prepareStatement(  
    32.  
  32.                     “insert into student_photo(name, filename, filedata)” 
    33.  
  33.                     + ” values(‘mary’, ?, ?)”);  
    34.  
  34.             //第一个参数为文件名  
    35.  
  35.             psm.setString(1, file.getName());  
    36.  
  36.             //第二个参数为文件的二进制流  
    37.  
  37.             psm.setBinaryStream(2, fis, fis.available());  
    38.  
  38.             // 执行  
    39.  
  39.             psm.executeUpdate();  
    40.  
  40.         } catch (Exception ex) {  
    41.  
  41.             ex.printStackTrace();  
    42.  
  42.         } finally {  
    43.  
  43.             //关闭打开的对像  
    44.  
  44.             if (fis != null){  
    45.  
  45.                 try {  
    46.  
  46.                     fis.close();  
    47.  
  47.                 } catch (IOException e) {  
    48.  
  48.                     e.printStackTrace();  
    49.  
  49.                 }  
    50.  
  50.             }  
    51.  
  51.             OperateDB.closeStatement(psm);  
    52.  
  52.         }  
    53.  
  53.     }  
    54.  
  54.     /**  
    55.  
  55.      * 从数据库中读Blob数据  
    56.  
  56.      * @param con  
    57.  
  57.      * @param srcFileName   要读取的文件名  
    58.  
  58.      * @param outFilePath   保存到本地的文件  
    59.  
  59.      */ 
    60.  
  60.     public static void readBlob(Connection con, String srcFileName,   
    61.  
  61.             String outFilePath){  
    62.  
  62.         Statement sm = null;  
    63.  
  63.         FileOutputStream fos = null;  
    64.  
  64.         InputStream is = null;  
    65.  
  65.         try {  
    66.  
  66.             sm = con.createStatement();  
    67.  
  67.             ResultSet rs = sm.executeQuery(  
    68.  
  68.                     “SELECT * FROM student_photo where name = ‘mary'” 
    69.  
  69.                     + ” and filename = ‘” + srcFileName + “‘”);  
    70.  
  70.             if (rs.next()) {  
    71.  
  71.                 // 从列中读取Blob数据  
    72.  
  72.                 Blob blob = rs.getBlob(“filedata”);  
    73.  
  73.           
    74.  
  74.                 // 获取Blob的字节数，是long类型，表示字节数很多。  
    75.  
  75.                 long blobLength = blob.length();  
    76.  
  76.                 // 可以通过blob的getBytes方法从Blob对象中提取字节数据  
    77.  
  77.                 // 也通过Blob对象的二进制输入流读数据  
    78.  
  78.                 is = blob.getBinaryStream();  
    79.  
  79.                 byte[] buffer = new byte[4096];  
    80.  
  80.                 int size;  
    81.  
  81.                 File file = new File(outFilePath);  
    82.  
  82.                 try {  
    83.  
  83.                     fos = new FileOutputStream(file);  
    84.  
  84.                     while ((size = is.read(buffer)) != –1){  
    85.  
  85.                         fos.write(buffer, 0, size);  
    86.  
  86.                     }  
    87.  
  87.                 } catch (IOException eee) {  
    88.  
  88.                     eee.printStackTrace();  
    89.  
  89.                 }  
    90.  
  90.             }  
    91.  
  91.             rs.close();  
    92.  
  92.         } catch (SQLException e) {  
    93.  
  93.             e.printStackTrace();  
    94.  
  94.         } finally {  
    95.  
  95.             OperateDB.closeStatement(sm);  
    96.  
  96.             if (is != null){  
    97.  
  97.                 try {  
    98.  
  98.                     is.close();  
    99.  
  99.                 } catch (IOException e) {  
    100.  
  100.                     e.printStackTrace();  
    101.  
  101.                 }  
    102.  
  102.             }  
    103.  
  103.             if (fos != null){  
    104.  
  104.                 try {  
    105.  
  105.                     fos.close();  
    106.  
  106.                 } catch (IOException e) {  
    107.  
  107.                     e.printStackTrace();  
    108.  
  108.                 }  
    109.  
  109.             }  
    110.  
  110.         }  
    111.  
  111.     }  
    112.  
  112.  
    113.  
  113.     public static void main(String[] args) throws ClassNotFoundException,  
    114.  
  114.             SQLException {  
    115.  
  115.         String dbName = “studentdb”;  
    116.  
  116.         String userName = “test”;  
    117.  
  117.         String password = “test”;  
    118.  
  118.           
    119.  
  119.         Connection con = null;  
    120.  
  120.         try {  
    121.  
  121.             // 获得数据库连接  
    122.  
  122.             con = DBConnector.getMySQLConnection(null, null, null, dbName,  
    123.  
  123.                     userName, password);  
    124.  
  124.             // 写Blob数据  
    125.  
  125.             BlobData.writeBlob(con, “C:/temp/mary_photo.jpg”);  
    126.  
  126.             // 读Blob数据  
    127.  
  127.             BlobData.readBlob(con, “mary_photo.jpg”, “C:/temp/mary_photo_db.jpg”);  
    128.  
  128.         } catch (ClassNotFoundException e1) {  
    129.  
  129.             throw e1;  
    130.  
  130.         } catch (SQLException e2) {  
    131.  
  131.             throw e2;  
    132.  
  132.         } finally {  
    133.  
  133.             // 关闭数据库连接  
    134.  
  134.             OperateDB.closeConnection(con);  
    135.  
  135.         }  
    136.  
  136.     }  
    137.  
  137. }  
    138.