`
sd8089730
  • 浏览: 259393 次
  • 性别: Icon_minigender_1
  • 来自: 吉林
社区版块
存档分类
最新评论

JDBC 插入、修改 Oracle Lob字段

OracleJDBCSQLCC++ 
阅读更多 
String DRIVER = "oracle.jdbc.driver.OracleDriver"; 
    /**
     * ORACLE连接用URL
     */
    private static final String URL = "jdbc:oracle:thin:@test2000:1521:orac";

    /**
     * 用户名
     */
    private static final String USER = "user";

    /**
     * 密码
     */
    private static final String PASSWORD = "pswd";

    /**
     * 数据库连接
     */
    private static Connection conn = null;

    /**
     * SQL语句对象
     */
    private static Statement stmt = null;

    /**
     * @roseuid 3EDA089E02BC
     */
    public LobPros()
    {

    }

    /**
     * 往数据库中插入一个新的CLOB对象
     *
     * @param infile - 数据文件
     * @throws java.lang.Exception
     * @roseuid 3EDA04A902BC
     */
    public static void clobInsert(String infile) throws Exception
    {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 插入一个空的CLOB对象 */
            stmt.executeUpdate("INSERT INTO TEST_CLOB VALUES ('111', EMPTY_CLOB())");
            /* 查询此CLOB对象并锁定 */
            ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
            while (rs.next()) {
                /* 取出此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* 向CLOB对象中写入数据 */
                BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
                BufferedReader in = new BufferedReader(new FileReader(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 修改CLOB对象（是在原CLOB对象基础上进行覆盖式的修改）
     *
     * @param infile - 数据文件
     * @throws java.lang.Exception
     * @roseuid 3EDA04B60367
     */
    public static void clobModify(String infile) throws Exception
    {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 查询CLOB对象并锁定 */
            ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
            while (rs.next()) {
                /* 获取此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* 进行覆盖式修改 */
                BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
                BufferedReader in = new BufferedReader(new FileReader(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 替换CLOB对象（将原CLOB对象清除，换成一个全新的CLOB对象）
     *
     * @param infile - 数据文件
     * @throws java.lang.Exception
     * @roseuid 3EDA04BF01E1
     */
    public static void clobReplace(String infile) throws Exception
    {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 清空原CLOB对象 */
            stmt.executeUpdate("UPDATE TEST_CLOB SET CLOBCOL=EMPTY_CLOB() WHERE ID='111'");
            /* 查询CLOB对象并锁定 */
            ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
            while (rs.next()) {
                /* 获取此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* 更新数据 */
                BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
                BufferedReader in = new BufferedReader(new FileReader(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * CLOB对象读取
     *
     * @param outfile - 输出文件名
     * @throws java.lang.Exception
     * @roseuid 3EDA04D80116
     */
    public static void clobRead(String outfile) throws Exception
    {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 查询CLOB对象 */
            ResultSet rs = stmt.executeQuery("SELECT * FROM TEST_CLOB WHERE ID='111'");
            while (rs.next()) {
                /* 获取CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* 以字符形式输出 */
                BufferedReader in = new BufferedReader(clob.getCharacterStream());
                BufferedWriter out = new BufferedWriter(new FileWriter(outfile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                out.close();
                in.close();
            }
        } catch (Exception ex) {
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 向数据库中插入一个新的BLOB对象
     *
     * @param infile - 数据文件
     * @throws java.lang.Exception
     * @roseuid 3EDA04E300F6
     */
    public static void blobInsert(String infile) throws Exception
    {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 插入一个空的BLOB对象 */
            stmt.executeUpdate("INSERT INTO TEST_BLOB VALUES ('222', EMPTY_BLOB())");
            /* 查询此BLOB对象并锁定 */
            ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE");
            while (rs.next()) {
                /* 取出此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
                /* 向BLOB对象中写入数据 */
                BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
                BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 修改BLOB对象（是在原BLOB对象基础上进行覆盖式的修改）
     *
     * @param infile - 数据文件
     * @throws java.lang.Exception
     * @roseuid 3EDA04E90106
     */
    public static void blobModify(String infile) throws Exception
    {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 查询BLOB对象并锁定 */
            ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE");
            while (rs.next()) {
                /* 取出此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
                /* 向BLOB对象中写入数据 */
                BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
                BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 替换BLOB对象（将原BLOB对象清除，换成一个全新的BLOB对象）
     *
     * @param infile - 数据文件
     * @throws java.lang.Exception
     * @roseuid 3EDA0505000C
     */
    public static void blobReplace(String infile) throws Exception
    {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 清空原BLOB对象 */
            stmt.executeUpdate("UPDATE TEST_BLOB SET BLOBCOL=EMPTY_BLOB() WHERE ID='222'");
            /* 查询此BLOB对象并锁定 */
            ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE");
            while (rs.next()) {
                /* 取出此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
                /* 向BLOB对象中写入数据 */
                BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
                BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * BLOB对象读取
     *
     * @param outfile - 输出文件名
     * @throws java.lang.Exception
     * @roseuid 3EDA050B003B
     */
    public static void blobRead(String outfile) throws Exception
    {
        /* 设定不自动提交 */
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 查询BLOB对象 */
            ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222'");
            while (rs.next()) {
                /* 取出此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
                /* 以二进制形式输出 */
                BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outfile));
                BufferedInputStream in = new BufferedInputStream(blob.getBinaryStream());
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态 */
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 建立测试用表格
     * @throws Exception
     */
    public static void createTables() throws Exception {
        try {
            stmt.executeUpdate("CREATE TABLE TEST_CLOB ( ID NUMBER(3), CLOBCOL CLOB)");
            stmt.executeUpdate("CREATE TABLE TEST_BLOB ( ID NUMBER(3), BLOBCOL BLOB)");
        } catch (Exception ex) {

        }
    }

    /**
     * @param args - 命令行参数
     * @throws java.lang.Exception
     * @roseuid 3EDA052002AC
     */
    public static void main(String[] args) throws Exception
    {
        /* 装载驱动,建立数据库连接 */
        Class.forName(DRIVER);
        conn = DriverManager.getConnection(URL,USER,PASSWORD);
        stmt = conn.createStatement();

        /* 建立测试表格 */
        createTables();

        /* CLOB对象插入测试 */
        clobInsert("c:/clobInsert.txt");
        clobRead("c:/clobInsert.out");

        /* CLOB对象修改测试 */
        clobModify("c:/clobModify.txt");
        clobRead("c:/clobModify.out");

        /* CLOB对象替换测试 */
        clobReplace("c:/clobReplace.txt");
        clobRead("c:/clobReplace.out");

        /* BLOB对象插入测试 */
        blobInsert("c:/blobInsert.doc");
        blobRead("c:/blobInsert.out");

        /* BLOB对象修改测试 */
        blobModify("c:/blobModify.doc");
        blobRead("c:/blobModify.out");

        /* BLOB对象替换测试 */
        blobReplace("c:/blobReplace.doc");
        blobRead("c:/bolbReplace.out");

        /* 关闭资源退出 */
        conn.close();
        System.exit(0);
    }
}

 

package com.copybzzh.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

import easy.sql.EasySQL;
import easy.sql.Session;
import easy.sql.SessionFactory;
import easy.sql.io.TextFileWriter;

public class CopyBzzh {
    //根据数据库名查询对应表

    public static void main(String[] args) {
        
        File folderfiles = new File("d:" + File.separator + "images");//文件夹路径
        File[] files = folderfiles.listFiles(); //获取所有文件
        Session session = null;
        PreparedStatement pst = null;
        PreparedStatement pst2 = null;
        java.sql.Statement stmt=null;
        try {
            session = SessionFactory.openSession(EasySQL.ORACLE, "jdbc:oracle:thin:@192.168.1.199:1521:oradb", "data", "data", false, EasySQL.ORACLE_DRIVER);

            boolean defaultCommit = session.getConnection().getAutoCommit();
            session.getConnection().setAutoCommit(false);

            String str = "PhotoName                  State";
            File file = new File(new Date().getTime() + ".txt"); //插入日志
            
            for (int i = 0; i < files.length; i++) { //循环遍历 文件夹下面图片
                
                String sfzh = files[i].getName().substring(0, files[i].getName().indexOf(".")); //获取文件名
                
                FileInputStream fis = new FileInputStream(files[i]);
                
                stmt = session.getConnection().createStatement();
                
                ResultSet rs = stmt.executeQuery("select zp from person2 where sfzh='" + sfzh + "' for update");//锁定选择文件
                
                System.out.println(files[i].getName()+"==开始");
                
                if (rs.next()) {
                    /* 获取blob字段 */
                    oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob("zp");
                    
                    /* 向BLOB对象中写入数据 */
                    BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
                    
                    BufferedInputStream in = new BufferedInputStream(fis);
                    int c1;
                    while ((c1 = in.read()) != -1) {
                        out.write(c1);
                    }
                    
                    /* 是否插入成功 */
                    str += "\r\n";
                    str += files[i].getName() + "      ok    "  ;
                    in.close();
                    out.close();
                }else{
                    str += "\r\n";
                    str += files[i].getName() + " false    "  ;
                }
                
                session.getConnection().commit();

                String lineStr = "";

                 fis.close();
            }
            session.close();
            TextFileWriter.write(file, str);
        } catch (FileNotFoundException e) {
            
            e.printStackTrace();
            
        } catch (SQLException e) {
            try {
                //出错回滚
                session.rollback();
            } catch (SQLException e1) {
                
                e1.printStackTrace();
            }
            e.printStackTrace();
        } catch (Exception e) {
            try {
                //出错回滚
                session.rollback();
            } catch (SQLException e1) {
                
                e1.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            try {
                stmt.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

 

分享到：
| session失效跳转frameset解决方案
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring+Hibernate处理Oracle lob字段（一）

    总之，处理Oracle数据库中的LOB字段需要对Spring、Hibernate以及Oracle JDBC驱动有深入理解。通过合理配置和使用相应的API，我们可以有效地管理大体积数据，实现与数据库的高效交互。在实际项目中，根据具体需求和...

    JDBC操纵Oracle数据库中的BLOB字段

    #### 查询LOB字段长度 要检查BLOB字段是否已写入数据，可以使用`DBMS_LOB.GETLENGTH`函数。这是一个示例SQL查询语句： ```sql SELECT DBMS_LOB.GETLENGTH(image) FROM bxxx; ``` 如果返回的值大于零，那么表示`...

    ORACLE数据库中插入大字段数据的解决方法

    在ORACLE数据库中插入大字段数据时，可能会遇到性能问题或者由于字段长度限制导致的错误。这类问题通常涉及LOB（Large Object）类型的字段，如CLOB（Character Large Object）和BLOB（Binary Large Object）。本篇...

    jdbc中如何处理Oracle___BLOB字段

    ### JDBC中如何处理Oracle BLOB字段 在Java开发过程中，特别是在使用JDBC（Java Database Connectivity）与Oracle数据库交互时，处理BLOB(Binary Large Object)类型的数据是一项常见的需求。BLOB通常用于存储大量的...

    oracle数据库的clob大字段在jdbc中的处理方式

    在JDBC中，CLOB对象被表示为`java.sql.Clob`接口的实例，提供了读取和修改CLOB字段的方法。 要读取CLOB字段并转换为String，你需要遵循以下步骤： 1. **建立连接**：使用`DriverManager.getConnection()`方法建立...

    jdbc+hibernate存取blob字段

    本篇将详细介绍如何使用JDBC（Java Database Connectivity）与Hibernate框架来操作Oracle数据库中的BLOB字段。 首先，Oracle数据库的BLOB字段提供了对大对象的高效存储，它的性能优于LONG字段，尤其适合存储大容量...

    关于oracle中clob字段查询慢的问题及解决方法

    最近在用oracle的过程中用到了对blob字段模糊查询的问题，对oracle来说，我并不是高手，找了很多的资料终于能够查出来了。 blob字段直接用 select * from table_name where column like ‘%%'查找的时候是不能实现...

    weblogic.jdbc.vendor.oracle.OracleResultSet jar包

    `OracleResultSet`是WebLogic针对Oracle数据库定制的一个结果集实现，它扩展了Java标准的`java.sql.ResultSet`接口，增加了对Oracle特定特性的支持，如大对象（LOB）处理。在处理存储大字段的数据时，`...

    mysql oracle 插入blob数据实例源码

    OracleLob lob = OracleLob.createTemporary(conn, true); InputStream fis = new FileInputStream(imageFile); lob.setBinaryStream(0, fis, (int) imageFile.length()); pstmt.setLob(2, lob); pstmt....

    Java与Oracle大字段读写（含代码）

    在Java中，我们可以使用JDBC（Java Database Connectivity）API来与Oracle数据库进行通信，其中`oracle.jdbc.driver.OraclePreparedStatement`和`oracle.jdbc.OracleResultSet`类提供了对BLOB字段的操作接口。...

    运用Java如何存取Oracle中的CLOB类型字段

    ### 运用Java如何存取Oracle中的CLOB类型字段 #### 概述 在数据库操作中，经常会遇到处理大量文本数据的需求，例如存储文章、新闻、文档等。Oracle数据库提供了CLOB（Character Large Object）类型来存储大容量的...

    将EXCEL数据 插入ORACLE数据库

    4. **通过ODBC/JDBC接口**：在编程语言如Python、Java或VBA中，利用ODBC或JDBC驱动连接到Oracle数据库，读取Excel数据，然后执行SQL插入语句。这种方法适用于小规模的数据导入，或者需要结合其他业务逻辑的情况。 5...

    oracle jdbc驱动 ojdbc14-10.2.0.4.0.jar工具

    Oracle JDBC驱动程序，即Oracle Java Database Connectivity驱动，是Oracle数据库与Java应用程序之间的桥梁，使得Java开发者可以使用Java语言访问和操作Oracle数据库。`ojdbc14-10.2.0.4.0.jar`是Oracle公司提供的一...

    通过JDBC连接oracle数据库的十大技巧

    ### 通过JDBC连接Oracle数据库的十大技巧 在IT领域，使用Java开发应用程序时，与数据库的交互是一项基本且重要的任务。JDBC（Java Database Connectivity）作为一种标准接口，提供了多种方式来实现Java程序与数据库...

    spring+hibernate操作oracle的clob字段

    在J2EE开发中，处理大数据对象（如大文本或二进制数据）时，Oracle数据库的CLOB字段常被用来存储超过4000字节的信息。Spring和Hibernate框架结合使用可以有效地进行CLOB字段的操作。以下是实现这一功能的关键步骤和...

    spring+hibernate 解决大字段（clob）

    本文将详细介绍如何在Spring与Hibernate框架结合的情况下，有效地处理Oracle 10g数据库中的CLOB字段。 #### 一、环境配置 为了确保项目能够顺利运行，首先需要搭建好开发环境。本示例中使用的环境配置如下： 1. *...

    Oracle大型数据对象LOB几种情况的示范类

    Oracle中的大型对象（LOB）是...总结来说，这篇文章通过`LobPros`类展示了如何在Oracle数据库中插入和修改CLOB对象，这对于处理大量文本数据的系统非常有用。了解如何有效地操作LOB对于开发存储大数据的应用至关重要。

Magicbox
Global site tag (gtag.js) - Google Analytics