Problem z buforowaniem InputStreamReader

Question

Czytam dane z pliku, który ma niestety dwa typy kodowania znaków.

Istnieje nagłówek i treść. Nagłówek zawsze znajduje się w ASCII i definiuje zestaw znaków, w którym kodowane jest ciało.

Nagłówek nie ma ustalonej długości i musi być uruchamiany przez parser w celu ustalenia jego zawartości/długości.

Plik może być dość duży, więc należy unikać umieszczania całej zawartości w pamięci.

Więc zacząłem od jednego InputStream. Zawijam go początkowo za pomocą InputStreamReader z ASCII i dekoduję nagłówek i wypakowuję zestaw znaków dla ciała. Wszystko dobrze.

Następnie tworzę nowy InputStreamReader z poprawnym zestawem znaków, upuszczam go na tym samym InputStream i zaczynam próbować czytać ciało.

Niestety wygląda na to, że javadoc potwierdza to, że InputStreamReader może zdecydować się na odczyt z wyprzedzeniem dla celów efektywności. Czytanie nagłówka przeżuwa część/całe ciało.

Czy ktoś ma jakieś sugestie dotyczące obejścia tego problemu? Czy ręczne tworzenie CharsetDecoder i karmienie w jednym bajcie, ale dobry pomysł (ewentualnie w niestandardowej implementacji Reader?)

Z góry dziękuję.

EDYCJA: Moje ostateczne rozwiązanie było napisanie InputStreamReader, który nie ma buforowanie, aby upewnić się, że mogę parsować nagłówek bez żucia części ciała. Chociaż nie jest to bardzo wydajne, zawijam surowy InputStream za pomocą BufferedInputStream, więc nie będzie problemu.

// An InputStreamReader that only consumes as many bytes as is necessary 
// It does not do any read-ahead. 
public class InputStreamReaderUnbuffered extends Reader 
{ 
    private final CharsetDecoder charsetDecoder; 
    private final InputStream inputStream; 
    private final ByteBuffer byteBuffer = ByteBuffer.allocate(1); 

    public InputStreamReaderUnbuffered(InputStream inputStream, Charset charset) 
    { 
     this.inputStream = inputStream; 
     charsetDecoder = charset.newDecoder(); 
    } 

    @Override 
    public int read() throws IOException 
    { 
     boolean middleOfReading = false; 

     while (true) 
     { 
      int b = inputStream.read(); 

      if (b == -1) 
      { 
       if (middleOfReading) 
        throw new IOException("Unexpected end of stream, byte truncated"); 

       return -1; 
      } 

      byteBuffer.clear(); 
      byteBuffer.put((byte)b); 
      byteBuffer.flip(); 

      CharBuffer charBuffer = charsetDecoder.decode(byteBuffer); 

      // although this is theoretically possible this would violate the unbuffered nature 
      // of this class so we throw an exception 
      if (charBuffer.length() > 1) 
       throw new IOException("Decoded multiple characters from one byte!"); 

      if (charBuffer.length() == 1) 
       return charBuffer.get(); 

      middleOfReading = true; 
     } 
    } 

    public int read(char[] cbuf, int off, int len) throws IOException 
    { 
     for (int i = 0; i < len; i++) 
     { 
      int ch = read(); 

      if (ch == -1) 
       return i == 0 ? -1 : i; 

      cbuf[ i ] = (char)ch; 
     } 

     return len; 
    } 

    public void close() throws IOException 
    { 
     inputStream.close(); 
    } 
} 

Answer 1

Dlaczego nie używasz 2 InputStream s? Jeden do czytania nagłówka i drugi do ciała.

Drugie InputStream powinno skip bajty nagłówka.

Answer 2

Moja pierwsza myśl to zamknąć strumień i ponownie go otworzyć, używając InputStream#skip, aby pominąć nagłówek, a następnie przekazać strumień do nowego InputStreamReader.

Jeśli naprawdę, naprawdę nie chcesz ponownie otwierać pliku, możesz użyć file descriptors, aby uzyskać więcej niż jeden strumień do pliku, chociaż być może będziesz musiał użyć wielu pozycji w pliku (ponieważ możesz Zakładam, że możesz zresetować pozycję za pomocą reset, może nie być obsługiwana).

Answer 3

Sugeruję ponowne przeczytanie strumienia od nowa z nowym InputStreamReader. Załóżmy, że obsługiwane jest InputStream.mark.

Answer 4

Oto pseudo kod.

1. Zastosowanie InputStream, ale nie owijać Reader wokół niego.
2. Przeczytaj bajty zawierające nagłówek i zapisz je do ByteArrayOutputStream.
3. Tworzenie ByteArrayInputStream z ByteArrayOutputStream i zdekodować nagłówek, tym razem owinąć ByteArrayInputStream do Reader z ASCII charset.
4. Obliczyć długość wejścia innego niż ascii i odczytać tę liczbę bajtów w innym ByteArrayOutputStream.
5. Utwórz kolejną ByteArrayInputStream z drugiego ByteArrayOutputStream i zawinąć go z Reader z charset od nagłówka .

Answer 5

jeszcze łatwiej:

Jak powiedziałeś, twój nagłówek jest zawsze w ASCII. Więc czytaj nagłówek bezpośrednio z InputStream, a kiedy skończysz z nim, stworzyć Reader z poprawnym kodowaniem i odczytać z niego

private Reader reader; 
private InputStream stream; 

public void read() { 
    int c = 0; 
    while ((c = stream.read()) != -1) { 
     // Read encoding 
     if (headerFullyRead) { 
      reader = new InputStreamReader(stream, encoding); 
      break; 
     } 
    } 
    while ((c = reader.read()) != -1) { 
     // Handle rest of file 
    } 
} 

Answer 6

Jeśli owinąć InputStream i ograniczyć wszystko czyta tylko 1 bajt na czas wydaje się wyłączać buforowanie wewnątrz InputStreamReader.

W ten sposób nie musimy przepisywać logiki InputStreamReader.

public class OneByteReadInputStream extends InputStream 
{ 
    private final InputStream inputStream; 

    public OneByteReadInputStream(InputStream inputStream) 
    { 
     this.inputStream = inputStream; 
    } 

    @Override 
    public int read() throws IOException 
    { 
     return inputStream.read(); 
    } 

    @Override 
    public int read(byte[] b, int off, int len) throws IOException 
    { 
     return super.read(b, off, 1); 
    } 
} 

Aby skonstruować:

new InputStreamReader(new OneByteReadInputStream(inputStream));