前言

　　前幾天臨時支援，幫pc端寫幾個介面，主要是對一個表的CRUD操作，雖然快兩年多沒寫後臺相關的東西了，但還不至於連一個表的基本的CRUD操作都忘了。但悲劇往往就來的這麼及時，表中有一個欄位是Clob型別的，以前沒怎麼處理過這種大欄位型別，網上查了下資料，感覺寫的五花八門，沒有一個完整的、適用的方法。通過參照別人的出來，加上自己的實踐，終於搞定。在此分享出來，希望給以後遇到同樣問題的人提供一些幫助。處理Clob型別的像hibernate、mybatis框架本身也提供了一些簡單的工具幫我們處理，先介紹使用最原始的的jdbc來處理。對於Blob型別的處理就不再介紹，同樣處理即可。
　　Clob型別的欄位最多可儲存2G的資料，不過超過5M的資料，我建議還是放到檔案裡面，資料庫放對應檔案的地址。至於兩種方式的利弊，不是本文重點，大家自行查之。　　

例項　

環境

• oracle11g
• tomcat 7.0
• jdk 1.8

資料庫表結構

jdbc方式

首先一個基本的jdbc連線類，還是貼下吧:

public class ConnectionUntils {
    private static Connection conn;
    private ConnectionUntils(){
        try {
            throw new Exception("can't be instance");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public
 
 static Connection getInstance(){
        if(conn == null){
            initConnection();
        }
        return conn;
    }
    private static void initConnection() {
        try {
            Class.forName("oracle.jdbc.driver.OracleDriver");// 載入Oracle驅動程式
            String url = "jdbc:oracle:" + "thin:@127.0.0.1:1521:orcl"
 
;
            String user = "lsh";
            String password = "lsh";
            conn = DriverManager.getConnection(url, user, password);// 獲取連線
        } catch (ClassNotFoundException e) { 
            e.printStackTrace();
        } catch (SQLException e) { 
            e.printStackTrace();
        } 
    }
    /*
     * 測試連線成功
     */
    /*public static void main(String[] args) {
        PreparedStatement pst = null;
        ResultSet rs = null;
        String sql = "select count(a_id) from article";
        Connection con = getInstance();
        try {
            pst = con.prepareStatement(sql);
            rs = pst.executeQuery();
            if(rs.next()){
                System.out.println(rs.getInt(1));
            }
        } catch (SQLException e) { 
            e.printStackTrace();
        }finally {
            close(rs,pst,con);
        }
    }*/
    public static void close(ResultSet rs, PreparedStatement pst, Connection connection) {
        try {
            if(rs!=null){
                rs.close();
                rs=null;
            }
            if(pst!=null){
                pst.close();
                pst=null;
            }
            if(connection!=null){
                connection.close();
            }
        } catch (SQLException e) { 
            e.printStackTrace();
        }
    }  
}

接下來是具體的增刪改查方法，先說增加，一般會插入一個空的clob到資料庫對應的欄位,然後鎖定該列，用Write將待插入字串寫入進去。重點：這兩步操作要放在同一個事務裡面。具體增加的方法如下:

public boolean save(Article article){
    boolean result = true;
    Connection conn = ConnectionUntils.getInstance(); 
    String sql = "insert into article values(?,?,empty_clob())";
    //鎖住該列，防止併發寫入時候該欄位同時被多次寫入造成錯誤
    String sqlClob = "select a_content from article where a_id=? for update";
    PreparedStatement pst =null;
    ResultSet rs = null;
    Writer writer = null; 
    try {
        conn.setAutoCommit(false);//設定不自動提交，開啟事務
        pst = conn.prepareStatement(sql);
        pst.setInt(1,article.getId());
        pst.setString(2,article.getName());
        pst.executeUpdate();

        pst= conn.prepareStatement(sqlClob);
        pst.setInt(1, article.getId());

        rs = pst.executeQuery();
        CLOB clob = null;
        if(rs.next()){
            try {
                clob = (CLOB) rs.getClob(1);
                writer = clob.getCharacterOutputStream(); //拿到clob的字元輸入流
                writer.write(article.getContent());
                writer.flush(); 
                writer.close();  
            } catch (IOException e) {
                e.printStackTrace();
            }
        } 
        conn.commit();
    } catch (SQLException e) { 
        result = false;
        try {
            conn.rollback();//當commit或者rollback後會自動釋放該列的鎖定
        } catch (SQLException e1) { 
            e1.printStackTrace();
        }
        e.printStackTrace();
    } finally {
        conn.setAutoCommit(true);//還原
        ConnectionUntils.close(rs, pst, conn);
    } 
    return result;
}

用Junit 測試：

@Test
public void testSave(){
    dao = new CrudClob();
    Article article = new Article();
    article.setId(1);
    article.setName("水滸傳");
    StringBuilder str = new StringBuilder();
    for(int i=0;i<6000000;i++){
        str.append("我是正文，我是正文，我是正文，我是正文，我是正文");
    } 
    article.setContent(str.toString());
    boolean result = dao.save(article);
    System.out.print(result);
}

將資料庫剛才插入的一條資料匯出到檔案：

article.sql裡面包括表結構和剛插入的一條資料，大小411MB，在我電腦上耗時36秒左右：

接下來看update操作，update時候主要利用PreparedStatement的setClob方法:

public boolean update(int id,String content){
    int result = 0;
    Connection conn = ConnectionUntils.getInstance(); 
    String sql = "update article set a_content=? where a_id=?";
    PreparedStatement pst =null;
    try {
        CLOB clob   = oracle.sql.CLOB.createTemporary(conn, false,oracle.sql.CLOB.DURATION_SESSION);
        clob.setString(1L, content);
        pst = conn.prepareStatement(sql); 
        pst.setClob(1, clob);
        pst.setInt(2,id);
        result = pst.executeUpdate();
    } catch (SQLException e) { 
        e.printStackTrace();
    }finally{
        ConnectionUntils.close(null, pst, conn);
    }
    if(result==0)
        return false;
    return true;
} 

查詢就主要是從結果集ResultSet中定位到對應的欄位後，往外讀：

public Article select(int id){
    Article article = new Article();
    Connection conn = ConnectionUntils.getInstance(); 
    String sql = "select a_id,a_name,a_content from article where a_id = ?";
    PreparedStatement pst =null;
    ResultSet rs = null;
    try {
        pst = conn.prepareStatement(sql);
        pst.setInt(1,id);
        rs = pst.executeQuery();
        StringBuilder builder = new StringBuilder();
        if(rs.next()){
            Clob clob = rs.getClob("a_content");
            Reader rd = clob.getCharacterStream();
            char [] str = new char[12];
            while(rd.read(str) != -1) {
                builder.append(new String(str));
            }
            article.setContent(builder.toString());
            article.setId(id);
            article.setName(rs.getString("a_name"));
        }
    } catch (SQLException e) { 
        e.printStackTrace();
    } catch (IOException e) { 
        e.printStackTrace();
    }finally{
        ConnectionUntils.close(rs, pst, conn);
    }
    return article;
}

刪除的方法和普通表一樣，就不在貼出。

hibernate方式

　　hibernate處理挺簡單的,hibernate4處理,clob型別在實體類裡面對應定一個一個Clob型別的欄位，對映： 　　

<property name="content" type="clob">
            <column name="a_content"/>
</property>

在插入對應欄位的地方建立一個clob即可。

Hibernate.getLobCreator(session).createBlob(str);

hibernate5就更簡單了，hibernate內部做了對應的處理，我們直接當string型別一樣處理即可。

@Entity
public class Article { 
    @Id 
    @Column(name="a_id")
    private int id;

    @Column(name="a_name")
    private String name;

    @Column(name="a_content") 
    private String content;

    public int getId() {
        return id;
    }
}

存的時候直接設定大資料到content，直接呼叫session.save()即可。

mybatis方式

　　mybatis處理也非常簡單，沒必要貼程式碼，只需要配置mapper對映的時候配置一個處理器就會自動幫我們轉型別處理。和String型別一樣處理即可。

<result column="a_content" property="content" jdbcType="Clob"  typeHandler="org.apache.ibatis.type.ClobTypeHandler"/> 

所有的程式碼已經打包上傳，如果有任何疑問請郵件：[email protected]。

下載地址