Filter (suchen und ersetzen) array von bytes in einen InputStream

Nicht sicher, dass Sie gewählt haben, ist der beste Ansatz, Ihr problem zu lösen.

Sagte, ich mag nicht (und haben in der Politik nicht zu) beantworten Sie die Fragen mit "nicht" so, hier geht...

Haben Sie einen Blick auf FilterInputStream.

Aus der Dokumentation:

Einen FilterInputStream enthält einige andere input-Streams, die es verwendet als grundlegende Quelle der Daten, möglicherweise die Umwandlung der Daten auf dem Weg oder die Bereitstellung zusätzlicher Funktionalität.

Es war eine lustige übung, um es zu schreiben. Hier ist ein vollständiges Beispiel für Sie:

import java.io.*;
import java.util.*;

class ReplacingInputStream extends FilterInputStream {

    LinkedList<Integer> inQueue = new LinkedList<Integer>();
    LinkedList<Integer> outQueue = new LinkedList<Integer>();
    final byte[] search, replacement;

    protected ReplacingInputStream(InputStream in,
                                   byte[] search,
                                   byte[] replacement) {
        super(in);
        this.search = search;
        this.replacement = replacement;
    }

    private boolean isMatchFound() {
        Iterator<Integer> inIter = inQueue.iterator();
        for (int i = 0; i < search.length; i++)
            if (!inIter.hasNext() || search[i] != inIter.next())
                return false;
        return true;
    }

    private void readAhead() throws IOException {
        //Work up some look-ahead.
        while (inQueue.size() < search.length) {
            int next = super.read();
            inQueue.offer(next);
            if (next == -1)
                break;
        }
    }

    @Override
    public int read() throws IOException {    
        //Next byte already determined.
        if (outQueue.isEmpty()) {
            readAhead();

            if (isMatchFound()) {
                for (int i = 0; i < search.length; i++)
                    inQueue.remove();

                for (byte b : replacement)
                    outQueue.offer((int) b);
            } else
                outQueue.add(inQueue.remove());
        }

        return outQueue.remove();
    }

    //TODO: Override the other read methods.
}

Beispiel Für Die Verwendung

class Test {
    public static void main(String[] args) throws Exception {

        byte[] bytes = "hello xyz world.".getBytes("UTF-8");

        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

        byte[] search = "xyz".getBytes("UTF-8");
        byte[] replacement = "abc".getBytes("UTF-8");

        InputStream ris = new ReplacingInputStream(bis, search, replacement);

        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        int b;
        while (-1 != (b = ris.read()))
            bos.write(b);

        System.out.println(new String(bos.toByteArray()));

    }
}

Angesichts der bytes für den string "Hello xyz world" es druckt:

Hello abc world

InformationsquelleAutor der Antwort aioobe

Brauchte ich so etwas wie gut und beschlossen, roll meine eigene Lösung statt mit dem Beispiel oben von @aioobe. Haben Sie einen Blick auf die code. Sie können ziehen Sie die Bibliothek aus dem maven-central, oder kopieren Sie einfach den Quellcode.

Dies ist, wie Sie es verwenden. In diesem Fall verwende ich eine verschachtelte Instanz zu ersetzen, die zwei Muster zwei fix dos-und mac-Zeilenenden.


new ReplacingInputStream(new ReplacingInputStream(is, "\n\r", "\n"), "\r", "\n");


Hier ist der vollständige code:

/**
 * Simple FilterInputStream that can replace occurrances of bytes with something else.
 */
public class ReplacingInputStream extends FilterInputStream {

    //while matching, this is where the bytes go.
    int[] buf=null;
    int matchedIndex=0;
    int unbufferIndex=0;
    int replacedIndex=0;

    private final byte[] pattern;
    private final byte[] replacement;
    private State state=State.NOT_MATCHED;

    //simple state machine for keeping track of what we are doing
    private enum State {
        NOT_MATCHED,
        MATCHING,
        REPLACING,
        UNBUFFER
    }

    /**
     * @param is input
     * @return nested replacing stream that replaces \n\r (DOS) and \r (MAC) line endings with UNIX ones "\n".
     */
    public static InputStream newLineNormalizingInputStream(InputStream is) {
        return new ReplacingInputStream(new ReplacingInputStream(is, "\n\r", "\n"), "\r", "\n");
    }

    /**
     * Replace occurances of pattern in the input. Note: input is assumed to be UTF-8 encoded. If not the case use byte[] based pattern and replacement.
     * @param in input
     * @param pattern pattern to replace.
     * @param replacement the replacement or null
     */
    public ReplacingInputStream(InputStream in, String pattern, String replacement) {
        this(in,pattern.getBytes(StandardCharsets.UTF_8), replacement==null ? null : replacement.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * Replace occurances of pattern in the input.
     * @param in input
     * @param pattern pattern to replace
     * @param replacement the replacement or null
     */
    public ReplacingInputStream(InputStream in, byte[] pattern, byte[] replacement) {
        super(in);
        Validate.notNull(pattern);
        Validate.isTrue(pattern.length>0, "pattern length should be > 0", pattern.length);
        this.pattern = pattern;
        this.replacement = replacement;
        //we will never match more than the pattern length
        buf = new int[pattern.length];
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        //copy of parent logic; we need to call our own read() instead of super.read(), which delegates instead of calling our read
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        int c = read();
        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;

        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;

    }

    @Override
    public int read(byte[] b) throws IOException {
        //call our own read
        return read(b, 0, b.length);
    }

    @Override
    public int read() throws IOException {
        //use a simple state machine to figure out what we are doing
        int next;
        switch (state) {
        case NOT_MATCHED:
            //we are not currently matching, replacing, or unbuffering
            next=super.read();
            if(pattern[0] == next) {
                //clear whatever was there
                buf=new int[pattern.length]; //clear whatever was there
                //make sure we start at 0
                matchedIndex=0;

                buf[matchedIndex++]=next;
                if(pattern.length == 1) {
                    //edgecase when the pattern length is 1 we go straight to replacing
                    state=State.REPLACING;
                    //reset replace counter
                    replacedIndex=0;
                } else {
                    //pattern of length 1
                    state=State.MATCHING;
                }
                //recurse to continue matching
                return read();
            } else {
                return next;
            }
        case MATCHING:
            //the previous bytes matched part of the pattern
            next=super.read();
            if(pattern[matchedIndex]==next) {
                buf[matchedIndex++]=next;
                if(matchedIndex==pattern.length) {
                    //we've found a full match!
                    if(replacement==null || replacement.length==0) {
                        //the replacement is empty, go straight to NOT_MATCHED
                        state=State.NOT_MATCHED;
                        matchedIndex=0;
                    } else {
                        //start replacing
                        state=State.REPLACING;
                        replacedIndex=0;
                    }
                }
            } else {
                //mismatch -> unbuffer
                buf[matchedIndex++]=next;
                state=State.UNBUFFER;
                unbufferIndex=0;
            }
            return read();
        case REPLACING:
            //we've fully matched the pattern and are returning bytes from the replacement
            next=replacement[replacedIndex++];
            if(replacedIndex==replacement.length) {
                state=State.NOT_MATCHED;
                replacedIndex=0;
            }
            return next;
        case UNBUFFER:
            //we partially matched the pattern before encountering a non matching byte
            //we need to serve up the buffered bytes before we go back to NOT_MATCHED
            next=buf[unbufferIndex++];
            if(unbufferIndex==matchedIndex) {
                state=State.NOT_MATCHED;
                matchedIndex=0;
            }
            return next;

        default:
            throw new IllegalStateException("no such state " + state);
        }
    }

    @Override
    public String toString() {
        return state.name() + " " + matchedIndex + " " + replacedIndex + " " + unbufferIndex;
    }

}

InformationsquelleAutor der Antwort Jilles van Gurp

Brauchte ich eine Lösung, aber die Antworten, die hier anfallen, zu viel Speicher und/oder CPU-overhead. Meine Lösung funktioniert für meinen Gebrauch Fall, ohne Frage, aber ich kann nicht Versprechen, es ist einwandfrei, wie eine Allgemeine Lösung.

Dies ist vor allem Speicher-effiziente, entstehen keine messbaren Kosten, auch mit >GB-streams.

Allem, dies ist nicht eine zero-cost-Lösung. Die CPU - /Verarbeitungs-Zeit Aufwand ist so gering wie ich es am morgen zwicken, und es ist wohl sinnvoll für alle, aber die meisten anspruchsvollen/Ressource-empfindliche Szenarien, aber der Aufwand ist real und sollte berücksichtigt werden bei der Bewertung der Kreditwürdigkeit der Einsatz dieser Lösung in einem gegebenen Kontext.

In meinem Fall unsere max-real-world-Datei Größe, die wir sind, die Verarbeitung ist über 6MB, wo wir sehen Latenz von etwa 170ms mit 44 Ersatz. Dies ist für eine Zuul-basierte reverse-proxy läuft auf AWS ECS mit einem single-CPU-Aktie (1024). Für die meisten Dateien (unter 100KB), die Latenz ist im sub-Millisekundenbereich. Unter hoher Parallelität (und damit CPU-Konflikte bestehen), die Latenz erhöhen könnte, aber wir sind derzeit in der Lage, Hunderte von Dateien, die gleichzeitig auf einem einzelnen Knoten mit kein menschlich-spürbare Latenz auswirken.

Die Lösung, die wir verwenden:

import java.io.IOException;
import java.io.InputStream;

public class TokenReplacingStream extends InputStream {

    private final InputStream source;
    private final byte[] oldBytes;
    private final byte[] newBytes;
    private int tokenMatchIndex = 0;
    private int bytesIndex = 0;
    private boolean unwinding;
    private int mismatch;
    private int numberOfTokensReplaced = 0;

    public TokenReplacingStream(InputStream source, byte[] oldBytes, byte[] newBytes) {
        assert oldBytes.length > 0;
        this.source = source;
        this.oldBytes = oldBytes;
        this.newBytes = newBytes;
    }

    @Override
    public int read() throws IOException {

        if (unwinding) {
            if (bytesIndex < tokenMatchIndex) {
                return oldBytes[bytesIndex++];
            } else {
                bytesIndex = 0;
                tokenMatchIndex = 0;
                unwinding = false;
                return mismatch;
            }
        } else if (tokenMatchIndex == oldBytes.length) {
            if (bytesIndex == newBytes.length) {
                bytesIndex = 0;
                tokenMatchIndex = 0;
                numberOfTokensReplaced++;
            } else {
                return newBytes[bytesIndex++];
            }
        }

        int b = source.read();
        if (b == oldBytes[tokenMatchIndex]) {
            tokenMatchIndex++;
        } else if (tokenMatchIndex > 0) {
            mismatch = b;
            unwinding = true;
        } else {
            return b;
        }

        return read();

    }

    @Override
    public void close() throws IOException {
        source.close();
    }

    public int getNumberOfTokensReplaced() {
        return numberOfTokensReplaced;
    }

}

InformationsquelleAutor der Antwort rees