it-roy-ru.com

Java - Как прочитать неизвестное количество байтов из inputStream (socket/socketServer)?

Нужно прочитать несколько байтов через сокет, используя inputStream. Отправленные сервером байты могут иметь переменное количество, и клиент заранее не знает длину байтового массива. Как это может быть достигнуто?


byte b[]; 
sock.getInputStream().read(b);

Это приводит к тому, что «Net BzEAnSZ» может не инициализировать ошибку. Помогите.

14
farm ostrich

Прочитайте int, который является размером следующего сегмента полученных данных. Создайте буфер с таким размером или используйте вместительный ранее существующий буфер. Прочитайте в буфер, убедившись, что он ограничен указанным выше размером. Промыть и повторить :)

Если вы действительно заранее не знаете размер, как вы сказали, прочитайте расширяющийся ByteArrayOutputStream, как уже упоминалось в других ответах. Однако метод размера действительно самый надежный.

11
Chris Dennett

Вам нужно расширить буфер по мере необходимости , читая кусками байтов 1024 за один раз, как в этом примере кода, который я написал некоторое время назад

    byte[] resultBuff = new byte[0];
    byte[] buff = new byte[1024];
    int k = -1;
    while((k = sock.getInputStream().read(buff, 0, buff.length)) > -1) {
        byte[] tbuff = new byte[resultBuff.length + k]; // temp buffer size = bytes already read + bytes last read
        System.arraycopy(resultBuff, 0, tbuff, 0, resultBuff.length); // copy previous bytes
        System.arraycopy(buff, 0, tbuff, resultBuff.length, k);  // copy current lot
        resultBuff = tbuff; // call the temp buffer as your result buff
    }
    System.out.println(resultBuff.length + " bytes read.");
    return resultBuff;
24
d-live

Предполагая, что отправитель закрывает поток в конце данных:

ByteArrayOutputStream baos = new ByteArrayOutputStream();

byte[] buf = new byte[4096];
while(true) {
  int n = is.read(buf);
  if( n < 0 ) break;
  baos.write(buf,0,n);
}

byte data[] = baos.toByteArray();
13
Vladimir Dyuzhev

Простой ответ:

byte b[] = byte[BIG_ENOUGH];
int nosRead = sock.getInputStream().read(b);

где BIG_ENOUGH достаточно большой.


Но в целом есть большая проблема с этим. Метод read - не гарантирован возвращает все, что другой конец записал за один вызов.

  • Если значение nosRead равно BIG_ENOUGH, ваше приложение не может точно знать, есть ли еще байты; другой конец мог отправить ровно BIG_ENOUGH байт ... или больше BIG_ENOUGH байт. В первом случае ваше приложение будет заблокировано (навсегда), если вы попытаетесь прочитать. В последнем случае ваше приложение должно сделать (как минимум) еще одну read, чтобы получить остальные данные.

  • Если значение nosRead меньше, чем BIG_ENOUGH, ваше приложение все еще не знает. Возможно, он получил все, что есть, часть данных могла быть отложена (из-за фрагментации сетевого пакета, потери сетевого пакета, сетевого раздела и т.д.), Или другой конец мог заблокироваться или потерпел крах на полпути при отправке данных.

Лучший ответ заключается в том, что вашему приложению нужно либо заранее знать, сколько байтов ожидать, либо «протокол приложения» должен каким-то образом сказать сколько ожидаемых байтов ... или когда все байты были отправлены. Возможные подходы:

  • протокол приложения использует фиксированные размеры сообщений
  • размеры сообщений протокола приложения указаны в заголовках сообщений
  • протокол приложения использует маркеры конца сообщения
  • протокол приложения не основан на сообщениях, а другой конец закрывает соединение, говоря «это конец».

Без одной из этих стратегий ваше приложение остается угаданным и может иногда ошибаться.

9
Stephen C

Не изобретая колесо, используя Apache Commons:

IOUtils.toByteArray(inputStream);

Например, полный код с обработкой ошибок:

    public static byte[] readInputStreamToByteArray(InputStream inputStream) {
    if (inputStream == null) {
        // normally, the caller should check for null after getting the InputStream object from a resource
        throw new FileProcessingException("Cannot read from InputStream that is NULL. The resource requested by the caller may not exist or was not looked up correctly.");
    }
    try {
        return IOUtils.toByteArray(inputStream);
    } catch (IOException e) {
        throw new FileProcessingException("Error reading input stream.", e);
    } finally {
        closeStream(inputStream);
    }
}

private static void closeStream(Closeable closeable) {
    try {
        if (closeable != null) {
            closeable.close();
        }
    } catch (Exception e) {
        throw new FileProcessingException("IO Error closing a stream.", e);
    }
}

Где FileProcessingException - это значимое исключение RT для вашего приложения, которое будет непрерывно передаваться вашему надлежащему обработчику без загрязнения кода между ними.

6
constv

Поток всех входных данных в выходной поток. Вот рабочий пример:

    InputStream inputStream = null;
    byte[] tempStorage = new byte[1024];//try to read 1Kb at time
    int bLength;
    try{

        ByteArrayOutputStream outputByteArrayStream =  new ByteArrayOutputStream();     
        if (fileName.startsWith("http"))
            inputStream = new URL(fileName).openStream();
        else
            inputStream = new FileInputStream(fileName);            

        while ((bLength = inputStream.read(tempStorage)) != -1) {
                outputByteArrayStream.write(tempStorage, 0, bLength);
        }
        outputByteArrayStream.flush();
        //Here is the byte array at the end
        byte[] finalByteArray = outputByteArrayStream.toByteArray();
        outputByteArrayStream.close();
        inputStream.close();
    }catch(Exception e){
        e.printStackTrace();
        if (inputStream != null) inputStream.close();
    }
1
DejanR

Этому вопросу 7 лет, но у меня была похожая проблема при создании NIO и OIO-совместимой системы (клиент и сервер могут быть любыми, OIO или NIO).

Это было решено из-за блокирования InputStreams.

Я нашел способ, который делает возможным, и я хочу опубликовать его, чтобы помочь людям с похожими проблемами.

Чтение байтового массива динамических sice выполняется здесь с помощью DataInputStream , который можно просто обернуть вокруг socketInputStream. Кроме того, я не хочу вводить конкретный коммуникационный протоколл (например, сначала посылать размер байтов, который будет отправлен), потому что я хочу сделать это как можно более Vanilla. Во-первых, у меня есть простая утилита класса Buffer, которая выглядит следующим образом:

import Java.util.ArrayList;
import Java.util.List;

public class Buffer {

    private byte[] core;
    private int capacity;

    public Buffer(int size){
        this.capacity = size;
        clear();
    }

    public List<Byte> list() {
        final List<Byte> result = new ArrayList<>();
        for(byte b : core) {
            result.add(b);
        }

        return result;
    }

    public void reallocate(int capacity) {
        this.capacity = capacity;
    }

    public void teardown() {
        this.core = null;
    }

    public void clear() {
        core = new byte[capacity];
    }

    public byte[] array() {
        return core;
    }
}

Этот класс существует только из-за глупого способа, байтовый автобокс <=> в Java работает с этим списком. В этом примере это совсем не нужно, но я не хотел ничего исключать из этого объяснения. 

Далее 2 простых основных метода. В них StringBuilder используется в качестве «обратного вызова». Он будет заполнен прочитанным результатом, а количество прочитанных байтов будет возвращено. Конечно, это может быть сделано иначе.

private int readNext(StringBuilder stringBuilder, Buffer buffer) throws IOException {
    // Attempt to read up to the buffers size
    int read = in.read(buffer.array());
    // If EOF is reached (-1 read)
    // we disconnect, because the
    // other end disconnected.
    if(read == -1) {
        disconnect();
        return -1;
    }
    // Add the read byte[] as
    // a String to the stringBuilder.
    stringBuilder.append(new String(buffer.array()).trim());
    buffer.clear();

    return read;
}

private Optional<String> readBlocking() throws IOException {
    final Buffer buffer = new Buffer(256);
    final StringBuilder stringBuilder = new StringBuilder();
    // This call blocks. Therefor
    // if we continue past this point
    // we WILL have some sort of
    // result. This might be -1, which
    // means, EOF (disconnect.)
    if(readNext(stringBuilder, buffer) == -1) {
        return Optional.empty();
    }
    while(in.available() > 0) {
        buffer.reallocate(in.available());
        if(readNext(stringBuilder, buffer) == -1) {
            return Optional.empty();
        }
    }

    buffer.teardown();

    return Optional.of(stringBuilder.toString());
}

Первый метод readNext заполнит буфер с byte[] из DataInputStream и вернет количество байтов, прочитанных таким образом.

Во втором методе readBlocking я использовал блокирующую природу, чтобы не беспокоиться о проблемах потребителя-производителя . Просто readBlocking будет блокировать, пока не будет получен новый байтовый массив. Прежде чем мы вызовем этот метод блокировки, мы выделяем размер буфера. Обратите внимание, я вызвал reallocate после первого чтения (внутри цикла while). Это не нужно. Вы можете безопасно удалить эту строку, и код все равно будет работать. Я сделал это из-за уникальности моей проблемы.

2 вещи, которые я не объяснил более подробно: 1. in (DataInputStream и единственный короткий вариант здесь, извините за это) 2. отключить (ваша процедура отключения)

В общем, теперь вы можете использовать его следующим образом:

// The in has to be an attribute, or an parameter to the readBlocking method
DataInputStream in = new DataInputStream(socket.getInputStream());
final Optional<String> rawDataOptional = readBlocking();
rawDataOptional.ifPresent(string -> threadPool.execute(() -> handle(string)));

Это предоставит вам способ чтения байтовых массивов любой формы или формы через сокет (или любой объект InputStream). Надеюсь это поможет!

0
Thorben Kuck

Вот более простой пример использования ByteArrayOutputStream ...

        socketInputStream = socket.getInputStream();
        int expectedDataLength = 128; //todo - set accordingly/experiment. Does not have to be precise value.
        ByteArrayOutputStream baos = new ByteArrayOutputStream(expectedDataLength);
        byte[] chunk = new byte[expectedDataLength];
        int numBytesJustRead;
        while((numBytesJustRead = socketInputStream.read(chunk)) != -1) {
            baos.write(chunk, 0, numBytesJustRead);
        }
        return baos.toString("UTF-8");

Однако, если сервер не возвращает -1, вам нужно будет определить конец данных другим способом - например, может быть, возвращаемый контент всегда заканчивается определенным маркером (например, ""), или вы могли бы решить используя socket.setSoTimeout (). (Упоминание об этом, как кажется, является распространенной проблемой.)

0
ban-geoengineering

Или:

  1. Попросите отправителя закрыть сокет после передачи байтов. Тогда в приемнике просто продолжайте читать до EOS.

  2. Попросите отправителя поставить префикс длинного слова в соответствии с предложением Криса, а затем прочитать столько байтов.

  3. Используйте протокол с самоописанием, такой как XML, Сериализация, ...

0
user207421

Это и поздний ответ, и самореклама, но любой, кто проверяет этот вопрос, может захотеть взглянуть сюда: https://github.com/GregoryConrad/SmartSocket

0
Flare Cat

Используйте BufferedInputStream и метод available(), который возвращает размер байтов, доступных для чтения, а затем создайте byte[] с этим размером. Задача решена. :) 

BufferedInputStream buf = new BufferedInputStream(is);  
int size = buf.available();
0
Abraham