使用JAVA读取ORACLE-BLOB字段实现上传下载.doc

使用JAVA读取ORACLE BLOB字段实现上传下载
大对象类型BLOB全称为Binary Large Objects，即二进制大对象。可以把BLOB区别为三种形式：声像数据、二进制数据和大文本数据。因此，最常见的应用就是存储图形、声音等对象，此外大二进制对象、OLE对象也可以通过BLOB类型存入数据库，如果文本对象过大，超出了文本类型的规定长度，则必须用BLOB字段进行存储。我们在经常使用的编程环境中并不能直接支持BLOB字段，因此需要调用相应的函数完成BLOB的使用。

二 实际Struts项目的处理流程
1 插入BLOB字段的流程
表示层：
上传使用struts的<html:file property="drawingFile"/>标签，提交给指定处理的Action，在ActionForm中使用struts自带的FormFile
来保存文件。
核心代码：
<html:form action="/DrawingInputMultiAction" enctype="multipart/form-data">
<html:file property="drawingFile"/>
....省略
</html:form>
控制层：
在Action中将传入的ActionForm中的文件字段赋给VO值对象，并调用业务代理类的上传方法。
核心代码：
        //新增
        if(actionType.equals("insert")) {
            //得到文件类型
            int iFileType = this.getFileType(drawingInputForm.getFileExtendName());
            if(iFileType == 0) {
                //不支持文件类型
                this.addError(request, "drawing.errors.upload.UnSupportedFileType");
            } else {
                DrawingVO objDrawingVO = new DrawingVO();
                //图纸基本属性
                objDrawingVO.setDrawingName(drawingInputForm.getDrawingName());
               ...省略其他set方法
                //执行新增（上传）
                int iRt = objDrawingMan.insertDrawing(objDrawingVO);
                ...省略
        }

Facade门面：
通过业务代理类调用DAO中的上传方法，对客户端完全透明。
    public int insertDrawing(DrawingVO drawingVO) throws ComtopModuleException {
        try {
            DrawingDAO drawingDAO = new DrawingDAO();
            return drawingDAO.insertDrawing(drawingVO);
        } catch(DrawingException ex) {
            throw new ComtopModuleException("drawing.errors.insert", ex);
        }
    }
持久层：
DAO中实现和ORACLE数据库的底层交涉，完成真正的文件上传。
需要先插入一个空BLOB对象，然后Update这个空对象。
    public int insertDrawing(DrawingVO drawingVO) throws DrawingException {
        PreparedStatement pstmt = null;
        Statement stmt = null;
        Connection conn = null;
        int iKey = 0;
        ResultSet rs = null;
        //定义SQL语句
        String strSQLInsert = null;
        String strSQLUpdate = null;
        try {
            conn = dataSource.getConnection();
            conn.setAutoCommit(false);
            //插入空BLOB，empty_blob(),其中表中的Content是BLOC类型字段
            strSQLInsert =
                "insert into PROD_DRAWING (DRAWING_ID, DRAWING_NAME, 省略..." +
                "CONTENT)" +
                "values (?, ?, 省略..., empty_blob())";
            //得到待处理文件
            FormFile drawingFile = drawingVO.getDrawingFile();
            //插入普通字段
            pstmt = conn.prepareStatement(strSQLInsert);
            //得到主键
            iKey = Toolkit.getInstance().getNextKey(DrawingInfo.ID_STORE_KEY_DRAWING);
            pstmt.setInt(1, iKey);
            ....省略其他set方法
            pstmt.executeUpdate();

            stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
                   ResultSet.CONCUR_UPDATABLE);
            strSQLUpdate =
                "SELECT CONTENT FROM PROD_DRAWING WHERE DRAWING_ID ='" +
                iKey + "'" + " FOR UPDATE";
            //读出记录以增加图片Blob字段
            rs = stmt.executeQuery(strSQLUpdate);
            if(rs.next()) {
                logger.debug("开始写入BLOB");
                //这里不能用oracle.sql.BLOB，会报ClassCast异常
                weblogic.jdbc.vendor.oracle.OracleThinBlob blob = (weblogic.jdbc.vendor.
                    oracle.
                    OracleThinBlob)rs.getBlob(1);
                logger.debug("得到输出流");
                OutputStream outStream = blob.getBinaryOutputStream();
                InputStream fin = drawingFile.getInputStream();
                logger.debug("开始分配缓存");
                byte[] b = new byte[blob.getBufferSize()];
                int len = 0;
                while((len = fin.read(b)) != -1) {
                    logger.debug("正在写入BLOB流");
                    outStream.write(b, 0, len);
                }
                logger.debug("关闭所有流");
                fin.close();
                outStream.flush();
                outStream.close();
            }
            rs.close();
            mit();
        } catch(Exception ex) {
        ...省略
        }finally {
            DBUtil.destroyDB(rs, pstmt, conn);
        }
        return iKey;
    }
2 读取BLOB字段的流程
从数据库中读出BLOB数据没有上述由于连接池的不同带来的差异，程序流程同插入BLOB字段，但是读BLOB就不用那么复杂了，只需要J2SE的标准类java.sql.Blob就可以取得输出流。

DAO中的核心代码：
    public DrawingVO readDrawing(int drawingId) throws DrawingException {
        PreparedStatement pstmt = null;
        Connection conn = null;
        DrawingVO objDrawingVO = null;
        ResultSet rs = null;
        //定义SQL语句
        String strSQL = "SELECT * FROM PROD_DRAWING WHERE DRAWING_ID=?";
        try {
            conn = dataSource.getConnection();
            pstmt = conn.prepareStatement(strSQL);
            //设置参数
            pstmt.setInt(1, drawingId);
            //执行查询
            rs = pstmt.executeQuery();
            while(rs.next()) {
                objDrawingVO = new DrawingVO();
                objDrawingVO.setDrawingId(rs.getInt("DRAWING_ID"));
                objDrawingVO.setDrawingName(rs.getString("DRAWING_NAME"));
               ...省略其他set方法
                //set BLOB到VO中
                objDrawingVO.setContent(rs.getBlob("CONTENT"));
            }
        } catch(Exception ex) {
            ...省略
        }finally {
            DBUtil.destroyDB(rs, pstmt, conn);
        }
        return objDrawingVO;
    }
这样，传到Action中VO对象就包含这个BLOB对象了，然后需要在Action中对该对象转为输入流，可以选择文件输出流或Servlet输出流，根据具体情况定，这里选择文件输出流。
核心代码：
    private String getBlobToFile(Blob blob, DrawingVO objDrawingVO) throws Exception {
        InputStream ins = blob.getBinaryStream();
        //用文件模拟输出流
        String strFileName = objDrawingVO.getDrawingName() + "." +
                             objDrawingVO.getFileExtendName();
        String strRootFilePath = this.getServlet().getServletContext().getRealPath("");
        String strFilePath = "/temp/" + strFileName;
        String contextFilePath = strRootFilePath + strFilePath;
       //定义文件对象
        File file = new File(this.getServlet().getServletContext().getRealPath("") + "/temp");
        if(!file.exists()) {
            file.mkdir();
        }
        //定义输出流
        OutputStream fout = new FileOutputStream(contextFilePath, true);
        //下面将BLOB数据写入文件
        byte[] b = new byte[1024];
        int len = 0;
        while((len = ins.read(b)) != -1) {
            fout.write(b, 0, len);
        }

        //依次关闭
        fout.close();
        ins.close();
        return strFilePath;
    }
最后，在Action中调用这个私有方法，完成读取操作。

import   java.io.*;   
import   java.sql.*;   

  public   class   BlobOperation   
  {   
  public   static   void   addLob(long   id,   String   binFile)   throws   SQLException   
  {   
  Connection   con   =   null;   
  PreparedStatement   ps   =   null;   
  ResultSet   rs   =   null;   

  try   
  {   
  con   =   ConnectionFactory.getConnection();   //换成你自己取连接的方法   
  con.setAutoCommit(false);   

  String   sql   =   "INSERT   INTO   Blob_Tbl(id,   binfile,   bincontent)";   
  sql   +=   "   VALUES(?,   ?,   ?)";   
  ps   =   con.prepareStatement(sql);   

  ps.setLong(1,   id);   
  ps.setString(2,   binFile);   
  ps.setBlob(3,   oracle.sql.BLOB.empty_lob());   

  ps.executeUpdate();   
  //DatabaseUtils.closeObject(ps);   

  ps   =   con.prepareStatement("SELECT   bincontent   FROM   Blob_Tbl   WHERE   id   =   "   +   id   +   "   for   update   ");   
  rs   =   ps.executeQuery();   

  if   (rs.next())   
  {   
  oracle.sql.BLOB   binContent   =   (oracle.sql.BLOB)   rs.getBlob(1);   

  /*   write   blob   content   */   
  OutputStream   binOut   =   binContent.getBinaryOutputStream();   
  BufferedOutputStream   out   =   new   BufferedOutputStream(binOut);   
  BufferedInputStream   in   =   new   BufferedInputStream(new   FileInputStream(binFile));   
  int   c;   
  while   ((c   =   in.read())   !=   -1)   
  {   
  out.write(c);   
  }   
  in.close();   
  out.close();   
  }   
  mit();   
  }   catch   (Exception   e)   
  {   
  e.printStackTrace();   
  try   
  {   
  con.rollback();   
  }   catch   (SQLException   se)   
  {   
  }   
  throw   new   SQLException(e.getMessage());   
  }   finally   
  {   
  DatabaseUtils.closeObject(rs,   ps,   con);   
  }   
  }   

  public   static   void   fetchLob(long   id,   String   filename)   throws   SQLException   
  {   
  Connection   con   =   null;   
  Statement   st   =   null;   
  ResultSet   rs   =   null;   

  try   
  {   
  con   =   ConnectionFactory.getConnection();   

  String   sql   =   "SELECT   *     From   Blob_Tbl   Where   id   =   "   +   id;   
  st   =   con.createStatement();   

  rs   =   st.executeQuery(sql);   
  while   (rs.next())   
  {   

  String   binFile   =   rs.getString("binfile");   
  oracle.sql.BLOB   binContent   =   (oracle.sql.BLOB)   rs.getBlob("bincontent");   

  /*   read   blob   content   */   
  BufferedOutputStream   out   =   new   BufferedOutputStream(new   FileOutputStream(filename));   
  BufferedInputStream   in   =   new   BufferedInputStream(binContent.getBinaryStream());   

  int   c;   
  while   ((c   =   in.read())   !=   -1)   
  {   
  out.write(c);   
  }   
  in.close();   
  out.close();   
  }   

  }   catch   (Exception   e)   
  {   
  throw   new   SQLException(e.getMessage());   
  }   finally   
  {   
  DatabaseUtils.closeObject(rs,   st,   con);   
  }   
  }   

  public   static   void   main(String[]   args)   throws   Exception   
  {   
  if   (args.length   ==   0)   
  {   
  addLob(1,   "a.jpg");   
  }   else   
  {   
  fetchLob(1,   args[0]);   
  }   
  }   
  }   

package com.semovy.test;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

/**
 *
 * @author semovy 测试向oracle 读,写文件Blob 读,写大文本Clob
 */
public class OracleBlobTest {
 private String driver = "oracle.jdbc.driver.OracleDriver";
 private String url = "jdbc:oracle:thin:@localhost:1521:teckotooling";
 private String user = "scott";
 private String pwd = "tiger";
 public OracleBlobTest() {
 }
 public static void main(String[] args) {
  OracleBlobTest obt = new OracleBlobTest();
  obt.writeBlob();
  obt.readBlob();
  obt.writeClob();
  obt.readClob();
 }

 /**
  * 读二进制文件
  *
  */
 private void readBlob() {
  Connection conn = null;
  try {
   conn = getConnection();
   Statement stmt = conn.createStatement();
   ResultSet rs = stmt.executeQuery("select * from test where id=1");
   byte[] buffer = new byte[1024];
   OutputStream out = new FileOutputStream("d:/360安全卫士定1.exe");
   int tempLen = 0;
   int amount = 0;
   if (rs.next()) {
    Blob blob = rs.getBlob("BINARYCONTENT");
    InputStream in = blob.getBinaryStream();
    while ((tempLen = in.read(buffer)) != -1) {
     out.write(buffer, 0, tempLen);
     amount += tempLen;
     System.out.println("已经读出并写:" + amount + " 字节");
    }
    System.out.println("已经读出并写:完成");
    out.flush();
    out.close();
    in.close();
    rs.close();
    stmt.close();
   }
  } catch (ClassNotFoundException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (SQLException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (IOException e) {
   System.out.println(e.getLocalizedMessage());
  } finally {
   try {
    if (conn != null)
     conn.close();
   } catch (SQLException e) {
    System.out.println(e.getLocalizedMessage());
   }
  }
 }
 /**
  * 写二进制文件
  *
  */
 private void writeBlob() {
  Connection conn = null;
  try {
   conn = getConnection();
   conn.setAutoCommit(false);
   String sql = null;
   Statement stmt = conn.createStatement();
   sql = "delete from test where id=1";
   stmt.executeUpdate(sql);
   sql = "insert into test(1,BINARYCONTENT,CLOBCONTENT) values(1,empty_blob(),empty_clob())";
   stmt.executeUpdate(sql);
   ResultSet rs = stmt.executeQuery("select * from test where id=1");
   if (rs.next()) {
    Blob blob = rs.getBlob("BINARYCONTENT");
    OutputStream out = ((oracle.sql.BLOB) blob).setBinaryStream(0);// 从0开始,否则写出的文件有差错
    int bufferSize = ((oracle.sql.BLOB) blob).getBufferSize();
    System.out.println("bufferSize :" + bufferSize);
    BufferedInputStream in = new BufferedInputStream(
      new FileInputStream("d:/360安全卫士定.exe"), bufferSize);
    byte[] b = new byte[bufferSize];
    int count = in.read(b, 0, bufferSize);
    int amount = 0;
    while (count != -1) {
     out.write(b, 0, count);
     amount += count;
     System.out.println("处理了 " + amount + " 字节");
     count = in.read(b, 0, bufferSize);
     System.out.println("处理了 " + amount + " 字节,成功");
    }
    out.close();
    out = null;
    in.close();
    mit();
   }

  } catch (ClassNotFoundException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (SQLException e) {
   try {
    conn.rollback();
   } catch (SQLException e1) {
    System.out.println(e1.getLocalizedMessage());
   }
   System.out.println(e.getLocalizedMessage());
  } catch (IOException e) {
   System.out.println(e.getLocalizedMessage());
  } finally {
   try {
    if (conn != null)
     conn.close();
   } catch (SQLException e) {
    System.out.println(e.getLocalizedMessage());
   }
  }
 }

 /**
  * 读大文本
  *
  */
 private void readClob() {
  Connection conn = null;
  try {
   conn = getConnection();
   Statement stmt = conn.createStatement();
   ResultSet rs = stmt.executeQuery("select * from test where id=2");
   String tempStr = null;
   if (rs.next()) {
    Clob clob = rs.getClob("CLOBCONTENT");
    if (clob != null) {
     Reader in = clob.getCharacterStream();
     BufferedReader br = new BufferedReader(in);
     System.out.println("开始读....");
     while ((tempStr = br.readLine()) != null) {
      System.out.println(tempStr);
     }
     System.out.println("读完成....");
     in.close();
    }
    rs.close();
    stmt.close();
   }
  } catch (ClassNotFoundException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (SQLException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (IOException e) {
   System.out