Oracle中大对象LOB之CLOB与BLOB的存储与操作方法

CREATE TABLE doc_repository (
  id        NUMBER PRIMARY KEY,
  title     VARCHAR2(200),
  content   CLOB, -- 默认 ENABLE STORAGE IN ROW
  attachment BLOB
);

CREATE TABLE media_archive (
  id        NUMBER PRIMARY KEY,
  filename  VARCHAR2(255),
  raw_data  BLOB DISABLE STORAGE IN ROW
);

CREATE TABLE article (
  id        NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
  slug      VARCHAR2(100) UNIQUE NOT NULL,
  title     VARCHAR2(255) NOT NULL,
  body      CLOB,
  cover_img BLOB,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
LOB(body) STORE AS SECUREFILE body_lob (
  CHUNK 4096                -- 每次读写最小单位设为4KB，匹配多数文本编辑粒度
  PCTVERSION 20             -- 保留20%旧版本用于多版本读一致性（MVCC）
  CACHE                     -- 热点CLOB常驻Buffer Cache，加速重复访问
  ENABLE STORAGE IN ROW     -- 允许小文本内联，兼顾效率与空间
  RETENTION MAX             -- 启用自动UNDO管理，无需手动清理
)
LOB(cover_img) STORE AS SECUREFILE img_lob (
  CHUNK 8192                -- 图像通常较大，保持默认8KB
  NOCACHE                   -- BLOB不缓存（避免挤占Buffer Cache）
  DISABLE STORAGE IN ROW    -- 强制外存，避免小图内联导致块膨胀
  COMPRESS HIGH             -- 启用高压缩（对PNG/JPEG效果有限，但对RAW有效）
  ENCRYPT                   -- 敏感图像启用透明数据加密（TDE）
);

-- 方式1：插入空LOB（推荐，语义清晰）
INSERT INTO article (slug, title, body, cover_img) 
VALUES ('java-lob-guide', 'Oracle LOB深度指南', EMPTY_CLOB(), EMPTY_BLOB());

-- 方式2：插入NULL（需确保应用层能安全处理NULL CLOB/BLOB）
INSERT INTO article (slug, title, body, cover_img) 
VALUES ('null-demo', 'NULL LOB示例', NULL, NULL);

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

public class ClobInsertExample {

    public static void insertArticleWithClob(Connection conn, String slug, String title, String markdownContent) 
            throws SQLException, IOException {
        
        String sql = "INSERT INTO article (slug, title, body) VALUES (?, ?, EMPTY_CLOB()) RETURNING body INTO ?";
        try (PreparedStatement ps = conn.prepareStatement(sql);
             ResultSet rs = ps.executeQuery()) {

            ps.setString(1, slug);
            ps.setString(2, title);

            // 执行插入，并通过RETURNING子句获取新生成的CLOB Locator
            if (rs.next()) {
                Clob clob = rs.getClob(1); // 获取刚创建的CLOB句柄

                // 方式A：使用Writer流式写入（推荐，自动处理字符编码）
                try (Writer writer = clob.setCharacterStream(1L)) { // 从位置1开始写
                    writer.write(markdownContent);
                }

                // 方式B：使用OutputStream（需注意编码转换）
                // try (OutputStream os = clob.setAsciiStream(1L)) {
                //     os.write(markdownContent.getBytes(StandardCharsets.UTF_8));
                // }
            }
        }
    }
}

public static String readClobAsTruncatedString(Clob clob, int maxChars) throws SQLException, IOException {
    if (clob == null) return null;

    StringBuilder sb = new StringBuilder();
    try (Reader reader = clob.getCharacterStream()) {
        char[] buffer = new char[4096];
        int totalRead = 0;
        int charsRead;

        while ((charsRead = reader.read(buffer)) != -1 && totalRead < maxChars) {
            int toAppend = Math.min(charsRead, maxChars - totalRead);
            sb.append(buffer, 0, toAppend);
            totalRead += toAppend;
            if (totalRead >= maxChars) break;
        }
    }
    return sb.toString();
}

// 使用示例：预览前500字符
String preview = readClobAsTruncatedString(clob, 500);
System.out.println("Preview: " + preview + "...");

public static void streamClobToHtmlConverter(Clob clob, Writer htmlWriter) 
        throws SQLException, IOException {
    try (Reader markdownReader = clob.getCharacterStream();
         Writer bufferedWriter = new BufferedWriter(htmlWriter)) {

        // 假设使用 commonmark-java 解析Markdown
        Parser parser = Parser.builder().build();
        HtmlRenderer renderer = HtmlRenderer.builder().build();
        Node document = parser.parseReader(markdownReader);
        renderer.render(document, bufferedWriter);
    }
}

public static void appendToClob(Connection conn, long articleId, String newComment) 
        throws SQLException, IOException {
    
    String sql = "SELECT body FROM article WHERE id = ? FOR UPDATE"; // 加行锁，防止并发覆盖
    try (PreparedStatement ps = conn.prepareStatement(sql);
         ResultSet rs = ps.executeQuery()) {

        ps.setLong(1, articleId);
        if (rs.next()) {
            Clob clob = rs.getClob("body");

            // 获取当前长度，追加到末尾
            long currentLength = clob.length();
            try (Writer writer = clob.setCharacterStream(currentLength + 1)) {
                writer.write("\n\n---\n");
                writer.write("【评论】" + newComment);
                writer.write("\n");
            }
        }
    }
}

public static void saveImageToBlob(Connection conn, long userId, InputStream imageStream, String mimeType) 
        throws SQLException, IOException {

    String sql = "INSERT INTO user_profile (user_id, avatar_type, avatar_data) " +
                 "VALUES (?, ?, EMPTY_BLOB()) RETURNING avatar_data INTO ?";
    try (PreparedStatement ps = conn.prepareStatement(sql);
         ResultSet rs = ps.executeQuery()) {

        ps.setLong(1, userId);
        ps.setString(2, mimeType);

        if (rs.next()) {
            Blob blob = rs.getBlob(1);

            // 使用 setBinaryStream 写入字节流（最高效）
            try (OutputStream os = blob.setBinaryStream(1L)) {
                byte[] buffer = new byte[8192];
                int len;
                while ((len = imageStream.read(buffer)) != -1) {
                    os.write(buffer, 0, len);
                }
            }
        }
    }
}

public static void serveBlobAsResponse(HttpServletResponse response, Connection conn, long fileId) 
        throws SQLException, IOException {

    String sql = "SELECT file_name, mime_type, file_data FROM uploaded_files WHERE id = ?";
    try (PreparedStatement ps = conn.prepareStatement(sql);
         ResultSet rs = ps.executeQuery()) {

        ps.setLong(1, fileId);
        if (rs.next()) {
            String fileName = rs.getString("file_name");
            String mimeType = rs.getString("mime_type");
            Blob blob = rs.getBlob("file_data");

            // 设置HTTP响应头
            response.setContentType(mimeType);
            response.setHeader("Content-Disposition", 
                "inline; filename=\"" + fileName + "\""); // 或 attachment 强制下载
            response.setContentLengthLong(blob.length());

            // 流式输出，不加载全量到内存
            try (InputStream is = blob.getBinaryStream();
                 OutputStream os = response.getOutputStream()) {

                byte[] buffer = new byte[16384];
                int len;
                while ((len = is.read(buffer)) != -1) {
                    os.write(buffer, 0, len);
                }
                os.flush();
            }
        } else {
            response.sendError(HttpServletResponse.SC_NOT_FOUND);
        }
    }
}

public static boolean isValidImageMimeType(InputStream is, String claimedMimeType) 
        throws IOException {
    
    // 读取前几个字节判断真实类型
    byte[] header = new byte[12];
    is.mark(header.length);
    int read = is.read(header);
    is.reset(); // 重置流位置，供后续写入使用

    if (read < 3) return false;

    // PNG: 89 50 4E 47
    if (read >= 4 && header[0] == (byte) 0x89 && header[1] == 0x50 && 
        header[2] == 0x4E && header[3] == 0x47) {
        return "image/png".equalsIgnoreCase(claimedMimeType);
    }
    // JPEG: FF D8 FF
    if (read >= 3 && header[0] == (byte) 0xFF && header[1] == (byte) 0xD8 && 
        header[2] == (byte) 0xFF) {
        return "image/jpeg".equalsIgnoreCase(claimedMimeType) || 
               "image/jpg".equalsIgnoreCase(claimedMimeType);
    }
    return false;
}

# application.yml (Spring Boot)
spring:
  datasource:
    hikari:
      connection-init-sql: "ALTER SESSION SET CURRENT_SCHEMA=YOUR_SCHEMA"
      # 关键：禁用LOB自动获取，由应用显式控制
      data-source-properties:
        oracle.jdbc.defaultLobPrefetchSize: "32768"  # 每次预取32KB，平衡I/O与内存
        oracle.jdbc.useFetchSizeWithLongColumn: "true" # 对LONG/CLOB/BLOB启用fetchSize

SELECT * FROM article WHERE id = 123; // 强制加载body和cover_img两个大LOB！

-- 仅查元数据
SELECT id, slug, title, created_at FROM article WHERE id = 123;

-- 需要内容时再单独查
SELECT body FROM article WHERE id = 123;

-- 需要图片时再单独查
SELECT cover_img FROM article WHERE id = 123;

-- 对已有表在线重定义为SecureFile并启用压缩
ALTER TABLE article 
  MODIFY (body LOB (body) STORE AS SECUREFILE (COMPRESS MEDIUM));

-- 查询压缩率（验证效果）
SELECT table_name, segment_name, compression, compress_for 
FROM user_lobs 
WHERE table_name = 'ARTICLE';

public static void batchInsertArticles(Connection conn, List<Article> articles) 
        throws SQLException {
    
    String sql = "INSERT INTO article (slug, title, body) VALUES (?, ?, EMPTY_CLOB())";
    try (PreparedStatement ps = conn.prepareStatement(sql)) {

        for (Article a : articles) {
            ps.setString(1, a.getSlug());
            ps.setString(2, a.getTitle());
            ps.addBatch(); // 添加到批处理
        }

        int[] results = ps.executeBatch(); // 一次网络往返执行全部
        System.out.println("Batch inserted " + results.length + " articles.");
    }
}

// 错误！驱动可能将长字符串截断或抛异常
ps.setString(3, veryLongText); // ×

// 正确：使用 setClob() 或 setCharacterStream()
ps.setClob(3, new SerialClob(veryLongText.toCharArray())); // √（需JDBC 4.0+）
// 或更推荐：使用匿名内部类模拟流式写入（兼容老驱动）
ps.setCharacterStream(3, new StringReader(veryLongText)); // √

// 错误：忘记关闭
Clob clob = rs.getClob("body");
String content = clob.getSubString(1, (int) clob.length()); // 内存爆炸！

// 正确：try-with-resources（JDBC 4.0+）
try (Clob clob = rs.getClob("body")) {
    String content = clob.getSubString(1, (int) clob.length());
} // 自动调用clob.free()

// 或手动free（兼容旧版）
Clob clob = rs.getClob("body");
try {
    // ... use clob
} finally {
    if (clob != null) clob.free();
}

// 危险！Jackson 默认调用 toString()，可能返回空字符串或异常
ObjectNode node = mapper.createObjectNode();
node.put("content", clob); // ×

// 正确：先转为字符串（且控制长度！）
node.put("content", readClobAsTruncatedString(clob, 10000)); // √

// 事务1：获取CLOB
Clob clob = rs.getClob("body"); 

// 事务1提交
conn.commit();

// 事务2：尝试使用已提交的clob（非法！）
clob.length(); // ORA-01002: fetch out of sequence 或 ORA-22275