JDBC 插入、修改 Oracle Lob字段

最新推荐文章于 2021-04-09 20:24:59 发布
最新推荐文章于 2021-04-09 20:24:59 发布
阅读量104 收藏
点赞数
文章标签： Oracle JDBC SQL C C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sd8089730/article/details/83942731
版权 
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();
            }
        }

    }

}

 

猪娃娃Lisa
关注
oracle lob表迁移,从oracle迁移带clob字段的表数据至postgresql
weixin_32600979的博客
04-04 496
在oarcle的sql脚本中字段长度超过4000执行会有异常，而在postgresql中超过4000仍可以正常执行，产品同时支持多个数据库，如oracle和postgresql，在基础数据较多时，只能通过导出基础数据相关表的dmp或backup文件进行升级部署。开发的时候以oracle作为开发库，需要将基础数据弄到postgresql制作backup文件，通过程序直接读oracle表写到postg...
jdbc如何插入clob_让我们回顾一下如何通过JDBC插入Clob或Blob
最佳 Java 编程
06-22 1075
jdbc如何插入clob LOB是所有数据库以及JDBC中的PITA。 正确处理它们需要花费几行代码，并且可以确保最终会出错。 因为您必须考虑以下几点： 首先，LOB是繁重的资源，需要特殊的生命周期管理。 分配LOB后，最好也“释放”它，以减轻GC的压力。 本文详细介绍了为什么需要释放吊球 分配和释放吊球的时间至关重要。 它的寿命可能比ResultSet ， PreparedStat...
通过JDBC操纵Oracle数据库LOB字段的分析
虫二的专栏~~在路上~~~
04-24 1583
在Oracle中，LOB（Large Object，大型对象）类型的字段现在用得越来越多了。因为这种类型的字段，容量大（最多能容纳4GB的数据），且一个表中可以有多个这种类型的字段，很灵活，适用于数据量非常大的业务领域（如图象、档案等）。而LONG、LONG RAW等类型的字段，虽然存储容量也不小（可达2GB），但由于一个表中只能有一个这样类型的字段的限制，现在已很少使用了。  LOB类型分为BL
oracle+lob+peformance,Oracle 修改LOB字段PCTVERSION 的方法 | 信春哥，系统稳，闭眼上线不回滚！...
weixin_42119989的博客
04-03 417
最近已经有好几位网友找我咨询怎么处理ORA-0155和ORA-22924错误了，错误信息都一样，如下：ORA-01555: snapshot too old: rollback segment number with name "" too smallORA-22924: snapshot too old在告警日志中，常见的ORA-01555错误基本都会伴随着SQL语句，并且说明SQL运行多少秒...
blob数据类型_一文看懂Oracle数据库lob大对象数据类型
weixin_39809140的博客
11-27 398
概述今天主要对Oracle数据库lob大对象数据类型字段的详细讲解，介绍ORACLE提供的CLOB，NCLOB，BLOB，BFILE共四种LOB类型。LOB概念lob为Oracle数据库的一个大对象数据类型,可以存储超过4000bytes的字符串，二进制数据，OS文件等大对象信息.最大可存储的容量根oracle的版本和oracle 块大小有关.LOB分类分为内部LOB和外部LOB。内部LOB包括C...
oracle插入blob大字段
qq_31261717的博客
08-13 511
1
Oracle 如何将图片插入BLOB字段
Hehuyi_In的博客
04-22 7193
开发要求把两张图片插入到表中，趁机学了下oracle把图片插入blob字段的方法 1. 在操作系统创建一个oracle用户可以访问的目录 mkdir -p /home/oracle/picture 2. 把图片上传到该目录并允许oracle用户访问 3. 在数据库中创建目录 create or replace directory images as '/home/ora...
Spring+Hibernate处理Oracle lob字段（一）
03-16
总之，处理Oracle数据库中的LOB字段需要对Spring、Hibernate以及Oracle JDBC驱动有深入理解。通过合理配置和使用相应的API，我们可以有效地管理大体积数据，实现与数据库的高效交互。在实际项目中，根据具体需求和...
关于oracle中clob字段查询慢的问题及解决方法
12-16
最近在用oracle的过程中用到了对blob字段模糊查询的问题，对oracle来说，我并不是高手，找了很多的资料终于能够查出来了。 blob字段直接用 select * from table_name where column like ‘%%'查找的时候是不能实现...
oracle中使用jdbc读写clob和blob字段
03-05
Oracle 中使用 JDBC 读写 CLOB 和 BLOB 字段 在 Oracle 中，使用 JDBC 读写 CLOB（Character Large OBject）和 BLOB（Binary Large OBject）字段是非常重要的。CLOB 和 BLOB 是 Oracle 中的 LOB（Large OBject）...
Oracle 修改BLOB数据
08-01 6840
修改Oracle中的BLOB数据
oracle 修改clob内容
91奔跑的蜗牛
02-20 9873
直接用update语句全部替换clob的内容，提示修改字段的内容过长，不可行。 可采用部分替换的方式： update 表 set 字段=replace(字段，'要被替换内容','替换内容') where 条件。 实例场景，假设clob字段的内容为 abcde ，要改成 aBbcde， replace(字段,'a','aB')  ...
oracle lob值是什么,关于Oracle数据库LOB大字段总结
weixin_30467861的博客
04-03 2366
概述在ORACLE数据库中，DBA_OBJECTS视图中OBJECT_TYPE为LOB的对象是什么东西呢？其实OBJECT_TYPE为LOB就是大对象(LOB)，它指那些用来存储大量数据的数据库字段。Oracle 11gR2 文档：http://download.oracle.com/docs/cd/E11882_01/Appdev.112/e18294/adlob_tables.htm#ADLO...
通过JDBC操纵Oracle数据库LOB字段的几种情况分析
06-11 740
通过JDBC操纵Oracle数据库LOB字段的几种情况分析纵横软件制作中心 雨亦奇2003-6-10 15:14:19在Oracle中，LOB（Large Object，大型对象）类型的字段现在用得越来越多了。因为这种类型的字段，容量大（最多能容纳4GB的
oracle添加clob字段,oracle数据库clob字段处理
weixin_34954308的博客
04-09 5335
1、指定待插入字符串类型为clob，可以使用过程或存储过程例子：DECLAREREALLYBIGTEXTSTRING CLOB := '待插入的海量字符串';BEGININSERT INTO test_table VALUES('test', REALLYBIGTEXTSTRING, '0');commit;end ;2、blob字段数据转换为clob类型CREATE OR REPLACE FUN...
JDBC操作LOB字段详解
莫等闲的专栏
07-08 4352
在Oracle中，lob类型主要是指：CLOB和BLOB，这两个类型都是用来存储大量数据而设计的。 Blob：是指二进制大对象也就是英文Binary Large Object的所写，是用来存储大量二进制数据。 Clob：是指大字符对象也就是英文Character Large Object的所写，用来存储大量文本数据。 一：操作CLOB(1)数据库表结构如
Lob字段数据删除，对应空间变化测试
DBA小站
06-09 2355
由于遇到某个系统需要新添加LOB字段，并且会有大量的插入删除操作，所以需要确认下lob字段在 大量数据操作之后总的体积大小变化是怎样的。猜想lob字段的大小并不会自动收缩，是持续增长的，需要手动干预收缩空间 --测试1 测试disable storage in row下的lob字段 --create table create table T_LOB_TEST (   id
ORACLE中LOB字段的使用和维护
luojun198610的专栏
11-04 869
 随着社会的发展，在现代信息系统的开发中，需要存储的已不仅仅是简单的文字信息，同时还包括一些图片和音像资料或者是超长的文本。比如开发一套旅游信息系统，每一个景点都有丰富的图片、音像资料和大量的文字介绍。这就要求后台数据库要有存储这些数据的能力。ORACLE公司在其Oracle8i中通过提供LOB字段实现了该功能。　　 　　为了便于读者的理解，我们先介绍一些基本的概念：　　　　在ORACLE数据
Oracle JDBC操作LOB字段：BLOB与CLOB实例解析
本文通过JDBC编程示例，展示了如何在Oracle数据库中对这两种类型的LOB字段进行读写操作。首先创建了两个测试表TEST_CLOB和TEST_BLOB，分别用于演示CLOB和BLOB的使用。接着，以CLOB为例，详细说明了如何插入一个新的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值