AI 助理
文档备案控制台
开发者社区 数据库 文章 正文

Java中将byte[]转为Blob对象

2017-11-14 4471
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
准备先把以前写的持久层及表示层框架写完再写loonframework-game包(实际上是想自己业余建站用，用现成的框架太无聊，重复发明轮子的最 大意义就在于解闷……)，在2005年时写过一个开头，由于自己没有整理文档，现在拿起来就觉得代码很乱，又懒于写文档，于是把一些心得类的东西整理一 下，用以备忘。

在此持久层框架中，我将持久化过程分为两个松耦合模块，第一模块封装jdbc操作，隐藏Connection及相关事务，处理driver差异后执行标准CRUD并释放资源，于第二模块进行实体映射操作。

但 和Spring JdbcTemplate等jdbc封装略有不同的是，我除了直接将结果集转为List和实体返回外，还引入了一个类似CachedRowSet但非继承 CachedRowSet或ResultSet的结果集cache实体（没有提供诸如CachedRowSet的execute功能，原因大家都知 道……PS:05年我用Hibernate还比较少，现在看来和Hierbante的ScrollableResults接口超级类似，颇感java技术 殊途同归|||）。

但在此类get数据时，由于我将所有ResultSet数据无差别以object方式存储，当object为二进制对象时，为实现blob和clob接口就需要进行数据转换，将二进制对象转为blob或clob实现，为此完成代码如下。

比较hibernate的blobimpl而言（hibernate的blobimpl只有getBinaryStream()实现，因为别的对它也没用……），实现了更多的函数以供调用。 

BlobImpl.java
package  org.loon.framework.dao.lob;

 import  java.io.BufferedInputStream;
 import  java.io.ByteArrayInputStream;
 import  java.io.ByteArrayOutputStream;
 import  java.io.IOException;
 import  java.io.InputStream;

 import  java.io.OutputStream;
 import  java.sql.Blob;
 import  java.sql.SQLException;

 import  org.loon.framework.Loon;
 import  org.loon.framework.helper.FileHelper;

 /**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:二进制大对象Blob实现，用于转化二进制对象为blob实例，只提供get部分方法(虽然象征性的写了
 * set实现，但没有对数据库进行操作，只是摆设……).
 * </p>
 * <p>
 * Copyright: Copyright (c) 2007
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * <p>
 * License: [url]http://www.apache.org/licenses/LICENSE-2.0[/url]
 * </p>
 * 
 * @author chenpeng
 * @email：[email]ceponline@yahoo.com.cn[/email]
 * @version 0.1
 */
public   class  BlobImpl  implements  Blob  {


    private byte[] _bytes = new byte[0];

    private int _length = 0;

    /**
     * 构造函数，以byte[]构建blob
     * 
     * @param bytes
     */
    public BlobImpl(byte[] bytes) {
        init(bytes);
    }

    /**
     * 构造函数，以InputStream构建blob
     * 
     * @param bytes
     */
    public BlobImpl(InputStream input) {
        init(FileHelper.read(input));
    }

    /**
     * 构造函数，以blob重新构建blob
     * 
     * @param bytes
     */
    public BlobImpl(Blob blob) {
        init(blobToBytes(blob));
    }

    /**
     * 初始化byte[]
     * 
     * @param b
     */
    private void init(byte[] bytes) {
        _bytes = bytes;
        _length = _bytes.length;
    }

    /**
     * 将blob转为byte[]
     * 
     * @param blob
     * @return
     */
    private byte[] blobToBytes(Blob blob) {
        BufferedInputStream is = null;
        try {
            is = new BufferedInputStream(blob.getBinaryStream());
            byte[] bytes = new byte[(int) blob.length()];
            int len = bytes.length;
            int offset = 0;
            int read = 0;
            while (offset < len
                    && (read = is.read(bytes, offset, len - offset)) >= 0) {
                offset += read;
            }
            return bytes;
        } catch (Exception e) {
            return null;
        } finally {
            try {
                is.close();
                is = null;
            } catch (IOException e) {
                return null;
            }

        }
    }

    /**
     * 获得blob中数据实际长度
     * 
     * @return
     * @throws SQLException
     */
    public long length() throws SQLException {
        return _bytes.length;
    }

    /**
     * 返回指定长度的byte[]
     * 
     * @param pos
     * @param len
     * @return
     * @throws SQLException
     */
    public byte[] getBytes(long pos, int len) throws SQLException {
        if (pos == 0 && len == length())
            return _bytes;
        try {
            byte[] newbytes = new byte[len];
            System.arraycopy(_bytes, (int) pos, newbytes, 0, len);
            return newbytes;
        } catch (Exception e) {
            throw new SQLException("Inoperable scope of this array");
        }
    }

    /**
     * 返回InputStream
     * 
     * @return
     * @throws SQLException
     */
    public InputStream getBinaryStream() throws SQLException {
        return new ByteArrayInputStream(_bytes);
    }

    /**
     * 获取此byte[]中start的字节位置
     * 
     * @param pattern
     * @param start
     * @return
     * @throws SQLException
     */
    public long position(byte[] pattern, long start) throws SQLException {
        start--;
        if (start < 0) {
            throw new SQLException("start < 0");
        }
        if (start >= _length) {
            throw new SQLException("start >= max length");
        }
        if (pattern == null) {
            throw new SQLException("pattern == null");
        }
        if (pattern.length == 0 || _length == 0 || pattern.length > _length) {
            return -1;
        }
        int limit = (int) _length - pattern.length;
        for (int i = (int) start; i <= limit; i++) {
            int p;
            for (p = 0; p < pattern.length && _bytes[i + p] == pattern[p]; p++) {
                if (p == pattern.length) {
                    return i + 1;
                }
            }
        }
        return -1;
    }

    /**
     * 获取指定的blob中start的字节位置
     * 
     * @param pattern
     * @param start
     * @return
     * @throws SQLException
     */
    public long position(Blob pattern, long start) throws SQLException {
        return position(blobToBytes(pattern), start);
    }

    /**
     * 不支持操作异常抛出
     * 
     */
    void nonsupport() {
        throw new UnsupportedOperationException("This method is not supported！");
    }

    /**
     * 释放Blob对象资源
     * 
     * @throws SQLException
     */
    public void free() throws SQLException {
        _bytes = new byte[0];
        _length = 0;
    }

    /**
     * 返回指定长度部分的InputStream，并返回InputStream
     * 
     * @param pos
     * @param len
     * @return
     * @throws SQLException
     */
    public InputStream getBinaryStream(long pos, long len) throws SQLException {
        return new ByteArrayInputStream(getBytes(pos, (int) len));
    }

    /**
     * 以指定指定长度将二进制流写入OutputStream，并返回OutputStream
     * 
     * @param pos
     * @return
     * @throws SQLException
     */
    public OutputStream setBinaryStream(long pos) throws SQLException {
        // 暂不支持
        nonsupport();
        pos--;
        if (pos < 0) {
            throw new SQLException("pos < 0");
        }
        if (pos > _length) {
            throw new SQLException("pos > length");
        }
        // 将byte[]转为ByteArrayInputStream
        ByteArrayInputStream inputStream = new ByteArrayInputStream(_bytes);
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        byte[] bytes = new byte[(int) pos];
        try {
            bytes = new byte[inputStream.available()];
            int read;
            while ((read = inputStream.read(bytes)) >= 0) {
                os.write(bytes, 0, read);
            }

        } catch (IOException e) {
            e.getStackTrace();
        }

        // 返回OutputStream
        return (OutputStream) os;
    }

    /**
     * 设定byte[]
     * 
     * @param pos
     * @param bytes
     * @param offset
     * @param size
     * @param copy
     * @return
     * @throws SQLException
     */
    private int setBytes(long pos, byte[] bytes, int offset, int size,
            boolean copy) throws SQLException {
        // 暂不支持
        nonsupport();
        pos--;
        if (pos < 0) {
            throw new SQLException("pos < 0");
        }
        if (pos > _length) {
            throw new SQLException("pos > max length");
        }
        if (bytes == null) {
            throw new SQLException("bytes == null");
        }
        if (offset < 0 || offset > bytes.length) {
            throw new SQLException("offset < 0 || offset > bytes.length");
        }
        if (size < 0 || pos + size > (long) Integer.MAX_VALUE
                || offset + size > bytes.length) {
            throw new SQLException();
        }
        // 当copy数据时
        if (copy) {
            _bytes = new byte[size];
            System.arraycopy(bytes, offset, _bytes, 0, size);
        } else { // 否则直接替换对象
            _bytes = bytes;
        }
        return _bytes.length;
    }

    /**
     * 设定指定开始位置byte[]
     * 
     * @param pos
     * @param bytes
     * @return
     * @throws SQLException
     */
    public int setBytes(long pos, byte[] bytes) throws SQLException {
        // 暂不支持
        nonsupport();
        return setBytes(pos, bytes, 0, bytes.length, true);
    }

    /**
     * 设定byte[]
     * 
     * @param pos
     * @param bytes
     * @param offset
     * @param len
     * @return
     * @throws SQLException
     */
    public int setBytes(long pos, byte[] bytes, int offset, int len)
            throws SQLException {
        // 暂不支持
        nonsupport();
        return setBytes(pos, bytes, offset, len, true);
    }

    /**
     * 截取相应部分数据
     * 
     * @param len
     * @throws SQLException
     */
    public void truncate(long len) throws SQLException {
        if (len < 0) {
            throw new SQLException("len < 0");
        }
        if (len > _length) {
            throw new SQLException("len > max length");
        }
        _length = (int) len;
    }

    public static void main(String[] args) {

        //获得一个指定文件的blob
        //PS:天地良心啊，没抄袭hibernate写法，无奈的写一样了，不过比他多实现了点方法……（还特意把函数改名，不然更像|||）……
        Blob blob = Loon.makeBlob("D:\test.txt"); 
        // 以byte[]获得blob实例
        //Blob blob = new BlobImpl(bytes);
        try {
            // getBytes测试
            // 取出0到blob结束范围的byte[]
            byte[] buffer = blob.getBytes(0, (int) blob.length());
            // 以gb2312编码将byte[]转为string显示
            System.out.println(new String(buffer, "gb2312"));

            // getBinaryStream测试
            BufferedInputStream is = new BufferedInputStream(blob
                    .getBinaryStream());
            buffer = new byte[(int) blob.length()];
            int len = buffer.length;
            int offset = 0;
            int read = 0;
            while (offset < len
                    && (read = is.read(buffer, offset, len - offset)) >= 0) {
                offset += read;
            }
            System.out.println(new String(buffer, "gb2312"));

            // getBinaryStream范围取值测试,取0to4的byte[]
            is = new BufferedInputStream(blob.getBinaryStream(0, 4));
            //将is转为byte[]后转为String显示
            System.out.println(FileHelper.readToString(is, "gb2312"));

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}


本文转自 cping 51CTO博客，原文链接:http://blog.51cto.com/cping1982/130046


文章标签：
Java
数据库连接
Spring
数据库
存储
科技小能手
目录
相关文章
BigFour
|
10月前
|
设计模式 网络协议 数据可视化
Java 设计模式之状态模式：让对象的行为随状态优雅变化
状态模式通过封装对象的状态，使行为随状态变化而改变。以订单为例，将待支付、已支付等状态独立成类，消除冗长条件判断，提升代码可维护性与扩展性，适用于状态多、转换复杂的场景。
BigFour
1097 157
艾伦~耶格尔
|
12月前
|
缓存 安全 Java
Java反射机制：动态操作类与对象
Java反射机制是运行时动态操作类与对象的强大工具，支持获取类信息、动态创建实例、调用方法、访问字段等。它在框架开发、依赖注入、动态代理等方面有广泛应用，但也存在性能开销和安全风险。本文详解反射核心API、实战案例及性能优化策略，助你掌握Java动态编程精髓。
艾伦~耶格尔
320 1
啦啦啦191
|
Java 数据库连接 API
Java 对象模型现代化实践 基于 Spring Boot 与 MyBatis Plus 的实现方案深度解析
本文介绍了基于Spring Boot与MyBatis-Plus的Java对象模型现代化实践方案。采用Spring Boot 3.1.2作为基础框架，结合MyBatis-Plus 3.5.3.1进行数据访问层实现，使用Lombok简化PO对象，MapStruct处理对象转换。文章详细讲解了数据库设计、PO对象实现、DAO层构建、业务逻辑封装以及DTO/VO转换等核心环节，提供了一个完整的现代化Java对象模型实现案例。通过分层设计和对象转换，实现了业务逻辑与数据访问的解耦，提高了代码的可维护性和扩展性。
啦啦啦191
538 1
啦啦啦191
|
前端开发 Java 数据库连接
java bo 对象详解_全面解析 java 中 PO,VO,DAO,BO,POJO 及 DTO 等几种对象类型
Java开发中常见的六大对象模型（PO、VO、DAO、BO、POJO、DTO）各有侧重，共同构建企业级应用架构。PO对应数据库表结构，VO专为前端展示设计，DAO封装数据访问逻辑，BO处理业务逻辑，POJO是简单的Java对象，DTO用于层间数据传输。它们在三层架构中协作：表现层使用VO，业务层通过BO调用DAO处理PO，DTO作为数据传输媒介。通过在线商城的用户管理模块示例，展示了各对象的具体应用。最佳实践包括保持分层清晰、使用工具类转换对象，并避免过度设计带来的类膨胀。理解这些对象模型的区别与联系。
啦啦啦191
1038 1
武汉频琵
|
存储 人工智能 JavaScript
Java从作用域到对象高级应用​
本内容详细讲解了JavaScript中的作用域类型（函数作用域、块作用域、全局作用域）、作用域链、垃圾回收机制、闭包、变量提升、函数参数、数组方法、内置构造函数、对象高级知识、原型链、对象赋值、深浅拷贝、递归、异常处理及this指向等内容，全面覆盖JS核心概念与编程技巧。
武汉频琵
144 0
蓝易云
|
Java
深入JavaSE：详解Java对象的比较。
总的来说，Java对象的比较就像海洋生物的比较，有外在的，有内在的，有面对所有情况的，也有针对特殊情况的。理解并掌握这些比较方式，就能更好地驾驭Java的世界，游刃有余地操作Java对象。
蓝易云
707 12
蓝易云
|
编解码 JavaScript 前端开发
【Java进阶】详解JavaScript的BOM（浏览器对象模型）
总的来说，BOM提供了一种方式来与浏览器进行交互。通过BOM，你可以操作窗口、获取URL、操作历史、访问HTML文档、获取浏览器信息和屏幕信息等。虽然BOM并没有正式的标准，但大多数现代浏览器都实现了相似的功能，因此，你可以放心地在你的JavaScript代码中使用BOM。
蓝易云
424 23
大数据文摘
|
存储 Java
Java对象的内存布局
在HotSpot虚拟机中，Java对象的内存布局分为三部分：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。对象头包含Mark Word、Class对象指针及数组长度；实例数据存储对象的实际字段内容；对齐填充用于确保对象大小为8字节的整数倍。
大数据文摘
251 0
智物科技库
|
Java 数据安全/隐私保护
Java 类和对象
本文介绍了Java编程中类和对象的基础知识，作为面向对象编程(OOP)的核心概念。类是对象的蓝图，定义实体类型；对象是具体实例，包含状态和行为。通过示例展示了如何创建表示汽车的类及其实例，并说明了构造函数、字段和方法的作用。同时，文章还探讨了访问修饰符的使用，强调封装的重要性，如通过getter和setter控制字段访问。最后总结了类与对象的关系及其在Java中的应用，并建议进一步学习继承等概念。
智物科技库
360 1
Remember_Ray
|
设计模式 缓存 Java
重学Java基础篇—Java对象创建的7种核心方式详解
本文全面解析了Java中对象的创建方式，涵盖基础到高级技术。包括`new关键字`直接实例化、反射机制动态创建、克隆与反序列化复用对象，以及工厂方法和建造者模式等设计模式的应用。同时探讨了Spring IOC容器等框架级创建方式，并对比各类方法的适用场景与优缺点。此外，还深入分析了动态代理、Unsafe类等扩展知识及注意事项。最后总结最佳实践，建议根据业务需求选择合适方式，在灵活性与性能间取得平衡。
Remember_Ray
900 3

热门文章

最新文章

  • 1
    PostgreSQL sql文件编码引起的数据导入乱码或查询字符集异常报错(invalid byte sequence)
  • 2
    ByteArray转byte[]的两种方式以及HeapByteBuffer&DirectByteBuffer
  • 3
    java中整型数据（byte、short、int、long）溢出的现象及原理
  • 4
    程序启动时报: Invalid byte tag in constant pool: 19
  • 5
    string byte 互转
  • 6
    Java中字节Byte和位Bit的关系
  • 7
    Android中Bitmap、Drawable、byte[]转换
  • 8
    位(bit) \字节(byte)\十六进制
  • 9
    字节码编程，Byte-buddy篇一《基于Byte Buddy语法创建的第一个HelloWorld》
  • 10
    MySQL - tinyint(1) 用 Java 转化为 Byte 的坑
  • 1
    Java 设计模式之策略模式：灵活切换算法的艺术
    2629
  • 2
    Java 设计模式之观察者模式：构建松耦合的事件响应系统
    672
  • 3
    Java 设计模式之状态模式：让对象的行为随状态优雅变化
    1097
  • 4
    java零基础学习者入门课程
    751
  • 5
    Java 设计模式之责任链模式：优雅处理请求的艺术
    950
  • 6
    【Azure Storage Account】Java Code访问Storage Account File Share的上传和下载代码示例
    625
  • 7
    百宝箱开放平台 ✖️ Java SDK
    1835
  • 8
    《深入理解Spring》：现代Java开发的核心框架
    1104
  • 9
    用Java语言实现一个自定义的ArrayList类
    420
  • 10
    从混沌到秩序：Java共享内存模型如何通过显式约束驯服并发？
    290

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！