Java 取消/编组base64编码的二进制数据作为流

我有一个应用程序，使用JAXB从Oracle数据库向XML导入和导出数据。现在数据库中有一些BLOB字段，其中包含上传的文件，我希望这些文件在XML中以base64编码字符串的形式存在。通过使用

@XmlSchemaType（name=“base64Binary”）

对JAXB进行开箱即用的操作非常好，如下所示：

@XmlType
public class DocumentTemplateFile {

    // other fields ommited

    @XmlElement(required = true)
    @XmlSchemaType(name = "base64Binary")
    private byte[] data;

    // other code ommited
}

此解决方案的问题是，由于字节数组，整个文件内容都存储在内存中。根据文件的大小，这可能会导致一些问题

因此，我想知道是否有一种方法可以创建一个

XmlAdapter

或类似的方法，从文件中获取流，这样我就可以直接从数据库的BLOB中获取流，而不必将整个内容存储在内存中。我在想类似的事情：

public class BlobXmlAdapter extends XmlAdapter<InputStream, OutputStream> {

  @Override
  public InputStream marshal(final OutputStream value) throws Exception {
    return null;
  }

  @Override
  public OutputStream unmarshal(final InputStream value) throws Exception {
    return null;
  }

}

公共类BlobXmlAdapter扩展了XmlAdapter{
@凌驾
公共InputStream封送处理（最终OutputStream值）引发异常{
返回null；
}
@凌驾
公共OutputStream解组（最终InputStream值）引发异常{
返回null；
}
}

---

这显然只是一个说明性的例子，这样你就可以知道我在找什么。最终解决方案不一定要使用

XmlAdater

s。我所需要的只是一种挂接取消/编组过程并通过缓冲区/队列流式传输数据的方法，而不是将所有内容存储在字节数组中。

创建自定义

XmlAdapter

，如下所示：

public class Base64FileAdapter extends XmlAdapter<String, File>{
    @Override
    public String marshal(File file) throws Exception {
        // todo: read file and convert to base64 and return
    }

    @Override
    public File unmarshal(String data) throws Exception {
        File file = File.createTempFile("dataFile", "binary");
        file.deleteOnExit();
        //todo: base64 decode string data and write bytes to file
        return file;
    }
}

public static void main(String[] args) throws Exception{
    DocumentTemplateFile obj = (DocumentTemplateFile)unmarshal(DocumentTemplateFile.class, new InputSource("sample.xml"));
    // obj.data refers to File which contains base64 encoded data
}

---

现在，整个二进制内容存储在文件中。您可以读取/写入此文件。在jvm退出时删除此文件。

此解决方案使用以下第三方库。您应该使用以下maven依赖项：

<dependency>
    <groupId>jlibs</groupId>
    <artifactId>jlibs-xsd</artifactId>
    <version>2.0</version>
</dependency>

<repository>
    <id>jlibs-snapshots-repository</id>
    <name>JLibs Snapshots Repository</name>
    <url>https://raw.githubusercontent.com/santhosh-tekuri/maven-repository/master</url>
    <layout>default</layout>
</repository>

现在将pojo更改为使用上述适配器：

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.io.File;

@XmlRootElement
public class DocumentTemplateFile {
    @XmlElement(required = true)
    public String userName;

    @XmlElement(required = true)
    @XmlSchemaType(name = "base64Binary")
    @XmlJavaTypeAdapter(Base64Adapter.class)
    public File data;
}

现在，应使用以下帮助器类读取xml文件：

import jlibs.xml.Namespaces;
import jlibs.xml.xsd.DOMLSInputList;
import jlibs.xml.xsd.XSParser;
import jlibs.xml.xsd.XSUtil;
import org.apache.xerces.xs.XSElementDeclaration;
import org.apache.xerces.xs.XSModel;
import org.apache.xerces.xs.XSSimpleTypeDefinition;
import org.apache.xerces.xs.XSTypeDefinition;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLFilterImpl;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.SchemaOutputResolver;
import javax.xml.namespace.QName;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.Result;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.stream.StreamResult;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Santhosh Kumar Tekuri
 */
public class JAXBBlobUtil{
    public static XSModel generateSchemas(Class clazz) throws Exception{
        final Map<String, ByteArrayOutputStream> schemas = new HashMap<String, ByteArrayOutputStream>();
        JAXBContext.newInstance(clazz).generateSchema(new SchemaOutputResolver(){
            @Override
            public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException{
                ByteArrayOutputStream bout = new ByteArrayOutputStream();
                schemas.put(suggestedFileName, bout);
                StreamResult result = new StreamResult(bout);
                result.setSystemId(suggestedFileName);
                return result;
            }
        });

        DOMLSInputList lsInputList = new DOMLSInputList();
        for(Map.Entry<String, ByteArrayOutputStream> entry : schemas.entrySet()){
            ByteArrayInputStream bin = new ByteArrayInputStream(entry.getValue().toByteArray());
            lsInputList.addStream(bin, entry.getKey(), null);
        }
        return new XSParser().parse(lsInputList);
    }

    private static Object unmarshal(Class clazz, InputSource is) throws Exception{
        XSModel xsModel = generateSchemas(clazz);
        JAXBContext context = JAXBContext.newInstance(clazz);
        SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        XMLReader xmlReader = factory.newSAXParser().getXMLReader();
        xmlReader = new Base64Filter(xmlReader, xsModel);
        return context.createUnmarshaller().unmarshal(new SAXSource(xmlReader, is));
    }

    private static class Base64Filter extends XMLFilterImpl{
        private XSModel schema;
        private List<QName> xpath = new ArrayList();
        private FileWriter fileWriter;
        public Base64Filter(XMLReader parent, XSModel schema){
            super(parent);
            this.schema = schema;
        }

        @Override
        public void startDocument() throws SAXException{
            xpath.clear();
            super.startDocument();
        }

        @Override
        public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException{
            super.startElement(uri, localName, qName, atts);

            xpath.add(new QName(uri, localName));
            XSElementDeclaration elem = XSUtil.findElementDeclaration(schema, this.xpath);
            if(elem!=null){
                XSTypeDefinition type = elem.getTypeDefinition();
                if(type.getTypeCategory()==XSTypeDefinition.SIMPLE_TYPE){
                    XSSimpleTypeDefinition simpleType = (XSSimpleTypeDefinition)type;
                    while(!Namespaces.URI_XSD.equals(simpleType.getNamespace()))
                        simpleType = (XSSimpleTypeDefinition)simpleType.getBaseType();
                    if("base64Binary".equals(simpleType.getName())){
                        try{
                            File file = File.createTempFile("data", "binary");
                            file.deleteOnExit();
                            fileWriter = new FileWriter(file);
                            String absolutePath = file.getAbsolutePath();
                            super.characters(absolutePath.toCharArray(), 0, absolutePath.length());
                        }catch(IOException ex){
                            throw new SAXException(ex);
                        }
                    }
                }
            }
        }

        @Override
        public void characters(char[] ch, int start, int length) throws SAXException{
            try{
                if(fileWriter==null)
                    super.characters(ch, start, length);
                else
                    fileWriter.write(ch, start, length);
            }catch(IOException ex){
                throw new SAXException(ex);
            }
        }

        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException{
            xpath.remove(xpath.size() - 1);
            try{
                if(fileWriter!=null)
                    fileWriter.close();
                fileWriter = null;
            }catch(IOException ex){
                throw new SAXException(ex);
            }
            super.endElement(uri, localName, qName);
        }
    };
}

---

但这并不能真正阻止整个文件在内存中，对吗？尽管我们暂时将文件存储在磁盘上，但只要JAXB执行编组过程，它仍然会作为base64编码字符串完全加载到内存中。因此，从内存消耗的角度来看，与使用字节数组的解决方案相比，我看不出有任何区别。我知道，您正在从JAXB加载100个这样的bean，与100个bean的二进制数据相比，只有当前解析的二进制数据在内存中。但是，如果我在一个bean实例的DB blob中有一个10MB的文件呢。由于

字符串

，该10MB数据将在内存中。这就是为什么在内存消耗方面，这与

byte[]

方法没有什么不同。由于内存消耗几乎相同，我更喜欢阵列解决方案，因为它性能更好，因为我没有向磁盘写入任何内容。在这种情况下，我建议使用SAX或STAXC。您可以举个例子吗？我想SAX或STAX的问题是我会失去JAXB的优势，不是吗？这个问题会经常发生，因为我在DB中有很多这样的BLOB字段，但是它仍然是非常孤立的，所以我不太愿意使用不同的技术重新编码所有内容，只是为了能够在项目的某些边缘流式传输二进制数据。理想的情况是，我可以在不改变JAXB处理的情况下钩住SAX或STAX。这可能吗？我不确定我是否完全理解这个代码。我猜，它应该在解组期间将base64解析的内容写入一个文件，这样我就可以在解析过程之后将文件内容存储到DB中，对吗？不管怎样，我认为XMLFilter的发展方向是正确的。编组过程是否有类似的情况，即。E当XML被封送时，筛选器获取事件？上述代码中的xmlfilter将base64内容写入文件。作为练习，您可以将其更改为解码并写入文件。对对于mashalling，您必须将整个文件放入内存，所以我离开了编组。

import jlibs.xml.Namespaces;
import jlibs.xml.xsd.DOMLSInputList;
import jlibs.xml.xsd.XSParser;
import jlibs.xml.xsd.XSUtil;
import org.apache.xerces.xs.XSElementDeclaration;
import org.apache.xerces.xs.XSModel;
import org.apache.xerces.xs.XSSimpleTypeDefinition;
import org.apache.xerces.xs.XSTypeDefinition;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLFilterImpl;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.SchemaOutputResolver;
import javax.xml.namespace.QName;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.Result;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.stream.StreamResult;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Santhosh Kumar Tekuri
 */
public class JAXBBlobUtil{
    public static XSModel generateSchemas(Class clazz) throws Exception{
        final Map<String, ByteArrayOutputStream> schemas = new HashMap<String, ByteArrayOutputStream>();
        JAXBContext.newInstance(clazz).generateSchema(new SchemaOutputResolver(){
            @Override
            public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException{
                ByteArrayOutputStream bout = new ByteArrayOutputStream();
                schemas.put(suggestedFileName, bout);
                StreamResult result = new StreamResult(bout);
                result.setSystemId(suggestedFileName);
                return result;
            }
        });

        DOMLSInputList lsInputList = new DOMLSInputList();
        for(Map.Entry<String, ByteArrayOutputStream> entry : schemas.entrySet()){
            ByteArrayInputStream bin = new ByteArrayInputStream(entry.getValue().toByteArray());
            lsInputList.addStream(bin, entry.getKey(), null);
        }
        return new XSParser().parse(lsInputList);
    }

    private static Object unmarshal(Class clazz, InputSource is) throws Exception{
        XSModel xsModel = generateSchemas(clazz);
        JAXBContext context = JAXBContext.newInstance(clazz);
        SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        XMLReader xmlReader = factory.newSAXParser().getXMLReader();
        xmlReader = new Base64Filter(xmlReader, xsModel);
        return context.createUnmarshaller().unmarshal(new SAXSource(xmlReader, is));
    }

    private static class Base64Filter extends XMLFilterImpl{
        private XSModel schema;
        private List<QName> xpath = new ArrayList();
        private FileWriter fileWriter;
        public Base64Filter(XMLReader parent, XSModel schema){
            super(parent);
            this.schema = schema;
        }

        @Override
        public void startDocument() throws SAXException{
            xpath.clear();
            super.startDocument();
        }

        @Override
        public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException{
            super.startElement(uri, localName, qName, atts);

            xpath.add(new QName(uri, localName));
            XSElementDeclaration elem = XSUtil.findElementDeclaration(schema, this.xpath);
            if(elem!=null){
                XSTypeDefinition type = elem.getTypeDefinition();
                if(type.getTypeCategory()==XSTypeDefinition.SIMPLE_TYPE){
                    XSSimpleTypeDefinition simpleType = (XSSimpleTypeDefinition)type;
                    while(!Namespaces.URI_XSD.equals(simpleType.getNamespace()))
                        simpleType = (XSSimpleTypeDefinition)simpleType.getBaseType();
                    if("base64Binary".equals(simpleType.getName())){
                        try{
                            File file = File.createTempFile("data", "binary");
                            file.deleteOnExit();
                            fileWriter = new FileWriter(file);
                            String absolutePath = file.getAbsolutePath();
                            super.characters(absolutePath.toCharArray(), 0, absolutePath.length());
                        }catch(IOException ex){
                            throw new SAXException(ex);
                        }
                    }
                }
            }
        }

        @Override
        public void characters(char[] ch, int start, int length) throws SAXException{
            try{
                if(fileWriter==null)
                    super.characters(ch, start, length);
                else
                    fileWriter.write(ch, start, length);
            }catch(IOException ex){
                throw new SAXException(ex);
            }
        }

        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException{
            xpath.remove(xpath.size() - 1);
            try{
                if(fileWriter!=null)
                    fileWriter.close();
                fileWriter = null;
            }catch(IOException ex){
                throw new SAXException(ex);
            }
            super.endElement(uri, localName, qName);
        }
    };
}

public static void main(String[] args) throws Exception{
    DocumentTemplateFile obj = (DocumentTemplateFile)unmarshal(DocumentTemplateFile.class, new InputSource("sample.xml"));
    // obj.data refers to File which contains base64 encoded data
}