Самый надежный способ чтения файла или потока с помощью Java (для предотвращения DoS-атак)

есть в основном 4 способа обработки файлов:

1. Потоковая Обработка (the java.io.InputStream модель): при необходимости поместите bufferedReader вокруг потока, повторите и прочитайте следующий доступный текст из потока (если текст недоступен, блок до тех пор, пока некоторые не станут доступными), обрабатывайте каждый кусок текста независимо, как он читается (питание для широко варьирующихся размеров текста кусочки)

2. Chunk На Основе Неблокирующей Обработки (the java.nio.channels.Channel модель): создайте набор буферов фиксированного размера (представляющих" куски " для обработки), считывайте в каждый из буферов по очереди без блокировки (NIO API делегирует собственный IO, используя быстрые потоки уровня O/S), ваш основной поток обработки выбирает каждый буфер по очереди после его заполнения и обрабатывает фиксированный размер куска, поскольку другие буферы продолжают асинхронно обрабатываться нагруженный.

3. обработка файлов деталей (включая построчную обработку) (может использовать (1) или (2) для изоляции или создания каждой "части"): разбейте формат файла на семантически значимые подчасти (если это возможно! можно было бы прорваться в строй!), итерация через части потока или куски и наращивание контента в памяти unitl следующая часть полностью построена, обрабатывать каждую часть, как только это построенный.

4. Вся Обработка Файла (the java.nio.file.Files модель): прочитайте весь файл в память за одну операцию, обработайте полное содержимое

какой из них следует использовать?
Это зависит от вашего содержимого файла и типа обработки, которую вы требуете.
С точки зрения эффективности использования ресурсов (от наилучшего к худшему): 1,2,3,4.
С точки зрения скорости и эффективности обработки (best к худшему) это: 2,1,3,4.
С точки зрения простоты программирования (от лучшего к худшему): 4,3,1,2.
Однако для некоторых типов обработки может потребоваться больше, чем самый маленький фрагмент текста (исключая 1 и, возможно, 2), а некоторые форматы файлов могут не иметь внутренних частей (исключая 3).

Вы делаете 4. Я предлагаю вам перейти на 3 (или ниже), если вы можете.

под 4, есть только один способ избежать DOS-ограничить размер, Прежде чем он будет считан в память, (или скопировать в файловую систему). Слишком поздно, когда все прочитано. Если это невозможно, попробуйте 3, 2 или 1.

Ограничение Размера Файла

часто файл загружается через HTML-форму.

при загрузке с помощью сервлета @MultipartConfig аннотации и request.getPart().getInputStream(), у вас есть контроль над тем, сколько данных читать из потока. Кроме того,request.getPart().getSize() возвращает размер файла заранее, и если он достаточно мал, вы можете сделать request.getPart().write(path) написать файл на диск.

если загрузка с помощью JSF, то JSF 2.2 (очень Новый) имеет стандартный html-компонент <h:inputFile> (javax.faces.component.html.InputFile), который имеет атрибут для maxLength; реализации pre-JSF 2.2 имеют аналогичные пользовательские компоненты (например, Tomahawk имеет <t:InputFileUpload> С maxLength атрибут; PrimeFaces имеет <p:FileUpload> С ).

Альтернативы для чтения всего файла

ваш код, который использует InputStream, StringBuilder и т. д., - Это эффективное способ прочитать весь файл, но не обязательно простой путь (наименьшие строки кода).

младшие / средние разработчики могут получить неправильное представление о том, что вы делаете эффективную потоковую обработку, когда вы обрабатываете весь файл-поэтому включите соответствующие комментарии.

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

 List<String> stringList = java.nio.file.Files.readAllLines(path, charset);

 or 

 byte[] byteContents =  java.nio.file.Files.readAllBytes(path);

но они требуют ухода, или они могут быть неэффективное использование ресурсов. Если вы используете readAllLines а затем объединить List элементы в единый String, тогда вы потребляете двойную память (для List элементы + сцепленный String). Аналогично, если вы используете readAllBytes, после кодирования String (new String(byteContents, charset)), то опять же, вы используете "двойные" память. Поэтому лучше всего обрабатывать непосредственно против List<String> или byte[], если вы не ограничиваете свои файлы до достаточно небольшого размера.

вместо readLine используйте read, который читает заданное количество символов.

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

дополнительно, я заметил, что вы не закрыли свой BufferedInputStream. Вы должны закрыть свой BufferedReader finally блок, поскольку это подвержено утечкам памяти.

...
} catch (IOException e) {
        // throw or handle the exception
    } finally{
       bufferedReader.close();
}

нет необходимости явно закрывать new InputStreamReader(inputStream) поскольку это будет автоматически закрыто при вызове для закрытия класса обертывания bufferedReader

я столкнулся с аналогичной проблемой при копировании огромного двоичного файла (который вообще не содержать символ новой строки). выполнение readline () приводит к чтению всего двоичного файла в одну строку, вызывающую OutOfMemory на кучу пространства.

вот простая альтернатива JDK:

public static void main(String[] args) throws Exception
{
    byte[] array = new byte[1024];
    FileInputStream fis = new FileInputStream(new File("<Path-to-input-file>"));
    FileOutputStream fos = new FileOutputStream(new File("<Path-to-output-file>"));
    int length = 0;
    while((length = fis.read(array)) != -1)
    {
        fos.write(array, 0, length);
    }
    fis.close();
    fos.close();
}

Примечание:

• приведенный выше пример копирует файл, используя буфер байт 1K. Однако, если вы делаете эту копию по сети, вы можете настроить размер буфера.

• Если вы хотите использовать FileChannel или библиотеки, такие как Commons IO, просто убедитесь, что реализация сводится к чему-то, как и выше

Я не могу придумать другого решения, кроме Apache Commons Io FileUtils. Его довольно просто с классом FileUtils, так как так называемая DOS-атака не будет поступать непосредственно с верхнего слоя. Чтение и запись файла очень просты, как вы можете сделать это только с одной строкой кода, как

String content =FileUtils.readFileToString(new File(filePath));

вы можете узнать больше об этом.

есть класс EntityUtils под Apache httpCore. Используйте метод getString () этого класса, чтобы получить строку из содержимого ответа.

это работает для меня без каких-либо проблем.

    char charArray[] = new char[ MAX_BUFFER_SIZE ];
    int i = 0;
    int c = 0;
    while((c = br.read()) != -1 && i < MAX_BUFFER_SIZE) {
        char character = (char) c;
        charArray[i++] = character;
   }
   return Arrays.copyOfRange(charArray,0,i);