bytearray.java

Java有关XML编程需要用到axis 的源代码 把里面bin下的包导入相应的Java工程 进行使用

/*
 * Copyright 2001-2004 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.axis.utils;

import org.apache.axis.AxisEngine;
import org.apache.axis.AxisProperties;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * Class ByteArray
 */
public class ByteArray extends OutputStream {

    protected static double DEFAULT_CACHE_INCREMENT = 2.5;
    protected static int DEFAULT_RESIDENT_SIZE = 512 * 1024 * 1024; // 512 MB
    protected static boolean DEFAULT_ENABLE_BACKING_STORE = true;
    protected static int WORKING_BUFFER_SIZE = 8192;

    protected org.apache.axis.utils.ByteArrayOutputStream cache = null;

    protected int max_size = 0;
    protected File bs_handle = null;
    protected OutputStream bs_stream = null;
    protected long count = 0;
    protected boolean enableBackingStore = DEFAULT_ENABLE_BACKING_STORE;

    public boolean isEnableBackingStore() {
        return enableBackingStore;
    }

    public void setEnableBackingStore(boolean enableBackingStore) {
        this.enableBackingStore = enableBackingStore;
    }

    public static boolean isDEFAULT_ENABLE_BACKING_STORE() {
        return DEFAULT_ENABLE_BACKING_STORE;
    }

    public static void setDEFAULT_ENABLE_BACKING_STORE(
            boolean DEFAULT_ENABLE_BACKING_STORE) {
        ByteArray.DEFAULT_ENABLE_BACKING_STORE = DEFAULT_ENABLE_BACKING_STORE;
    }

    public static int getDEFAULT_RESIDENT_SIZE() {
        return DEFAULT_RESIDENT_SIZE;
    }

    public static void setDEFAULT_RESIDENT_SIZE(int DEFAULT_RESIDENT_SIZE) {
        ByteArray.DEFAULT_RESIDENT_SIZE = DEFAULT_RESIDENT_SIZE;
    }

    public static double getDEFAULT_CACHE_INCREMENT() {
        return DEFAULT_CACHE_INCREMENT;
    }

    public static void setDEFAULT_CACHE_INCREMENT(
            double DEFAULT_CACHE_INCREMENT) {
        ByteArray.DEFAULT_CACHE_INCREMENT = DEFAULT_CACHE_INCREMENT;
    }

    static {
        String value;
        value = AxisProperties.getProperty(
                AxisEngine.PROP_BYTE_BUFFER_CACHE_INCREMENT,
                "" + DEFAULT_CACHE_INCREMENT);
        DEFAULT_CACHE_INCREMENT = Double.parseDouble(value);
        value = AxisProperties.getProperty(
                AxisEngine.PROP_BYTE_BUFFER_RESIDENT_MAX_SIZE,
                "" + DEFAULT_RESIDENT_SIZE);
        DEFAULT_RESIDENT_SIZE = Integer.parseInt(value);
        value = AxisProperties.getProperty(
                AxisEngine.PROP_BYTE_BUFFER_WORK_BUFFER_SIZE,
                "" + WORKING_BUFFER_SIZE);
        WORKING_BUFFER_SIZE = Integer.parseInt(value);
        value =
                AxisProperties.getProperty(AxisEngine.PROP_BYTE_BUFFER_BACKING,
                        "" + DEFAULT_ENABLE_BACKING_STORE);
        if (value.equalsIgnoreCase("true") ||
                value.equals("1") ||
                value.equalsIgnoreCase("yes")) {
            DEFAULT_ENABLE_BACKING_STORE = true;
        } else {
            DEFAULT_ENABLE_BACKING_STORE = false;
        }
    }

    /**
     * Constructor ByteArray
     */
    public ByteArray() {
        this(DEFAULT_RESIDENT_SIZE);
    }

    /**
     * Constructor ByteArray
     *
     * @param max_resident_size
     */
    public ByteArray(int max_resident_size) {
        this(0, max_resident_size);
    }

    /**
     * Constructor ByteArray
     *
     * @param probable_size
     * @param max_resident_size
     */
    public ByteArray(int probable_size, int max_resident_size) {
        if (probable_size > max_resident_size) {
            probable_size = 0;
        }
        if (probable_size < WORKING_BUFFER_SIZE) {
            probable_size = WORKING_BUFFER_SIZE;
        }
        cache = new org.apache.axis.utils.ByteArrayOutputStream(probable_size);
        max_size = max_resident_size;
    }

    /**
     * Method write
     *
     * @param bytes
     * @throws IOException
     */
    public void write(byte bytes[]) throws IOException {
        write(bytes, 0, bytes.length);
    }

    /**
     * Method write
     *
     * @param bytes
     * @param start
     * @param length
     * @throws IOException
     */
    public void write(byte bytes[], int start, int length) throws IOException {
        count += length;
        if (cache != null) {
            increaseCapacity(length);
        }
        if (cache != null) {
            cache.write(bytes, start, length);
        } else if (bs_stream != null) {
            bs_stream.write(bytes, start, length);
        } else {
            throw new IOException("ByteArray does not have a backing store!");
        }
    }

    /**
     * Method write
     *
     * @param b
     * @throws IOException
     */
    public void write(int b) throws IOException {
        count += 1;
        if (cache != null) {
            increaseCapacity(1);
        }
        if (cache != null) {
            cache.write(b);
        } else if (bs_stream != null) {
            bs_stream.write(b);
        } else {
            throw new IOException("ByteArray does not have a backing store!");
        }
    }

    /**
     * Method close
     *
     * @throws IOException
     */
    public void close() throws IOException {
        if (bs_stream != null) {
            bs_stream.close();
            bs_stream = null;
        }
    }

    /**
     * Method size
     *
     * @return
     */
    public long size() {
        return count;
    }

    /**
     * Method flush
     *
     * @throws IOException
     */
    public void flush() throws IOException {
        if (bs_stream != null) {
            bs_stream.flush();
        }
    }

    /**
     * Method increaseCapacity
     *
     * @param count
     * @throws IOException
     */
    protected void increaseCapacity(int count) throws IOException {
        if (cache == null) {
            return;
        }
        if (count + cache.size() <= max_size) {
            return;
        } else if (enableBackingStore) {
            switchToBackingStore();
        } else {
            throw new IOException("ByteArray can not increase capacity by " +
                    count +
                    " due to max size limit of " + max_size);
        }
    }

    /**
     * Method discardBuffer
     */
    public synchronized void discardBuffer() {
        cache = null;
        if (bs_stream != null) {
            try {
                bs_stream.close();
            } catch (IOException e) {
                // just ignore it...
            }
            bs_stream = null;
        }
        discardBackingStore();
    }

    /**
     * Method makeInputStream
     *
     * @return
     * @throws IOException
     * @throws FileNotFoundException
     */
    protected InputStream makeInputStream()
            throws IOException, FileNotFoundException {
        close();
        if (cache != null) {
            return new ByteArrayInputStream(cache.toByteArray());
        } else if (bs_handle != null) {
            return createBackingStoreInputStream();
        } else {
            return null;
        }
    }

    /**
     * Method finalize
     */
    protected void finalize() {
        discardBuffer();
    }

    /**
     * Method switchToBackingStore
     *
     * @throws IOException
     */
    protected void switchToBackingStore() throws IOException {
        bs_handle = File.createTempFile("Axis", ".msg");
        bs_handle.createNewFile();
        bs_handle.deleteOnExit();
        bs_stream = new FileOutputStream(bs_handle);
        bs_stream.write(cache.toByteArray());
        cache = null;
    }

    /**
     * Method getBackingStoreFileName
     *
     * @throws IOException
     */
    public String getBackingStoreFileName() throws IOException {
        String fileName = null;
        if (bs_handle != null) {
            fileName = bs_handle.getCanonicalPath();
        }
        return fileName;
    }

    /**
     * Method discardBackingStore
     */
    protected void discardBackingStore() {
        if (bs_handle != null) {
            bs_handle.delete();
            bs_handle = null;
        }
    }

    /**
     * Method createBackingStoreInputStream
     *
     * @return
     * @throws FileNotFoundException
     */
    protected InputStream createBackingStoreInputStream()
            throws FileNotFoundException {
        try {
            return new BufferedInputStream(
                    new FileInputStream(bs_handle.getCanonicalPath()));
        } catch (IOException e) {
            throw new FileNotFoundException(bs_handle.getAbsolutePath());
        }
    }

    /**
     * Method toByteArray
     *
     * @return
     * @throws IOException
     */
    public byte[] toByteArray() throws IOException {
        InputStream inp = this.makeInputStream();
        byte[] buf = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        buf = new byte[WORKING_BUFFER_SIZE];
        int len;
        while ((len = inp.read(buf, 0, WORKING_BUFFER_SIZE)) != -1) {
            baos.write(buf, 0, len);
        }
        inp.close();
        discardBackingStore();
        return baos.toByteArray();
    }

    /**
     * Method writeTo
     *
     * @param os
     * @throws IOException
     */
    public void writeTo(OutputStream os) throws IOException {
        InputStream inp = this.makeInputStream();
        byte[] buf = null;
        buf = new byte[WORKING_BUFFER_SIZE];
        int len;
        while ((len = inp.read(buf, 0, WORKING_BUFFER_SIZE)) != -1) {
            os.write(buf, 0, len);
        }
        inp.close();
        discardBackingStore();
    }
}