Принцип анализа
Во время разработки функция «точки непрерывной передачи» очень практична и распространена, а также звучит более «стандартной». Итак, мы обычно заинтересованы в изучении того, как эта функция реализована?
В Java вы также можете найти много информации о реализации аналогичных функций в Интернете. Тем не менее, большинство из них дают демонстрацию и публикуют исходный код. Есть очень мало подробных объяснений его принципа реализации.
Поэтому, когда мы впервые вступили в контакт с ним, мы могли бы просто непосредственно использовать коды CRTL + C/V, а затем поболтать с ним, но мы, наконец, можем получить эффект. Но делать это, когда вы новички, очевидно, хорошо и плохо.
Преимущество заключается в том, что существует много исходных кодов и несколько объяснений; Если мы готовы усердно работать, мы будем искать информацию и изучать вещи, которые мы не понимаем в коде, опубликованном другими. В конце концов, вы, вероятно, получите много наград.
Недостатки также очевидны: как новичок, сталкиваясь с большим количеством исходного кода, кажется, что многие вещи незнакомы, поэтому легко быть пугающим. Даже если у вас есть грубое понимание использования в конце, вы не обязательно понимаете принцип реализации.
Сегодня давайте начнем с самой основной точки зрения и посмотрим, действительно ли так называемое «продолжение точки останова» на самом деле настолько «высоким классом».
На самом деле, когда вы вступаете в контакт с новой «вещью», вы можете превратить его в то, с чем мы больше знакомы, чтобы ссылаться, сравнивать и учиться. Обычно это будет вдвое больше, чем половина усилий.
Если мы только что подвергаемся концепции «непрерывной передачи точки останова», определенно будет сложно объяснить одно, два и три. Тогда мы обязательно будем знакомы с «играми в игры».
Хорошо, тогда давайте предположим, что теперь у нас есть «игра RPG четкого уровня». Подумайте о том, что мы обычно делаем, играя в такую игру?
Очевидно, что в первый день мы сражались с кровавыми битвами и убили всех, предполагая, что мы наконец прибыли на четвертый уровень. Хотя ожесточенная битва была в полном разгаре, когда я посмотрел на часы на стене, было уже 12 часов утра, и пришло время лечь спать.
Это было очень неловко в это время. Чтобы успешно идти в ногу с прогрессом нашей игры в следующий раз, когда мы играем, что нам делать?
Это очень просто. Мы не выключаем игру, мы ложимся спать и продолжаем играть на следующий день. Это нормально, но кажется, что есть что -то, что заставляет людей чувствовать себя некомфортно.
Итак, в настоящее время, если в игре есть функция, называемая «Сохранить», это будет очень важно. Мы прямо выбираем архив, вводим имя архива «Четвертый уровень», а затем мы можем закрыть игру.
Когда мы играем в игру в следующий раз, мы напрямую найдем сохранение «четвертого уровня», затем прочитаем файл, а затем мы сможем продолжать играть в игру.
В настоящее время так называемая «непрерывная передача» проста »легко понять. Давайте следуем нашей предыдущей идее «Игра в игры»:
Предположим, есть файл, который нам нужно скачать сейчас. Когда мы загружаем его часть, возникает ситуация, такая как: компьютер вылетает, питание выходит, сеть прерывается и т. Д.
На самом деле, это похоже на то, что когда мы играли в игры раньше, нам внезапно нужно было лечь спать и отдохнуть в 12 часов. Хорошо, тогда ситуация в настоящее время такова:
• Если игра не может быть сохранена, это означает, что в следующий раз, когда мы играем, прогресс 4 уровней, которые прошли это время, будут потеряны, и мы не сможем следовать игре.
• Соответственно, если поведение «скачать» не может записать прогресс этой загрузки. Затем, когда мы загружаем этот файл снова, мы можем только начать все сначала.
На данный момент мы фактически обнаружили, что ключом к поведению, которое мы упомянули выше, является слово « продолжить »!
Чтобы достичь цели «продолжения» отключенного поведения, ключом состоит в том, чтобы «СМИ», способные записывать и читать информацию о узле, где поведение имеет «прерывание».
Преобразовать в мир программирования
На самом деле, это самый основной принцип «непрерывной передачи точки останова». Проще говоря, нам нужно записать информацию о местоположении прерывания, когда поведение загрузки прервано, а затем прочитать ее в следующем поведении.
С помощью этой информации о месте подумайте о том, что мы должны делать. Да, это очень просто. Когда начинается новое поведение загрузки, загружайте контент непосредственно с этого места записи и больше не начинается с нуля.
Ну, мы говорили о принципе так долго на простом языке и начали чувствовать себя скучно. Итак, давайте обобщу это в конце, а затем посмотрим, как мы должны преобразовать принципы в мир программирования.
• Когда «поведение загрузки (загрузка)» прерывается, нам нужно записать местоположение (положение) этой загрузки (загрузка).
• Когда начинается поведение «продолжения», мы прыгаем прямо к сообщению, чтобы продолжить загрузку (загрузка).
Очевидно, что ключ к проблеме заключается в так называемой «позиции». В «игре прохождения уровня», которую мы упомянули, «какой уровень» можно использовать в качестве единицы этой позиции.
Поэтому, когда мы переключаемся на так называемую «непрерывную передачу точки», что мы должны использовать для измерения «позиции»? Очевидно, что он вернулся к бинарному, потому что суть здесь - это не что иное, как чтение и написание файлов.
Тогда остальная часть работы очень проста. Во -первых, запишите позицию, о которой, кажется, не стоит говорить, потому что это просто настойчивость данных (память, файлы, база данных), и у нас есть много способов.
Другой ключ заключается в том, что когда начинается «продолжение» поведение, нам нужно начать операции чтения и записи с позиции, которую мы записали в прошлый раз, поэтому нам нужно что -то похожее на функцию «указателя».
Конечно, мы также можем найти способ реализовать такой «указатель», но рады, что Java предоставила нам такой класс, то есть случайный файл.
Функция этого класса интуитивно отражается в своем имени, и она может получить доступ к файлам случайным образом. Давайте посмотрим на описание этого класса в документации API:
Экземпляры этого класса Поддержка чтения и записи в случайно доступных файлах. Случайный доступ к файлам ведет себя как большой байтовый массив, хранящийся в файловой системе.
Если файл случайным образом доступен в режиме чтения/записи, операция вывода также доступна; Операция вывода начинается с указателя файла и продвигает указатель файла, когда написан байт.
Выходная операция после записи на текущий конец неявного массива заставляет массив расширяться. Указатель файла можно прочитать через метод GetFilePointer и установить метод поиска.
Прочитав инструкции API, мы засмеялись. Да, разве это не то, что мы хотим? Ну, мы так долго заточили наш нож, почему бы нам не нарезать древесину?
Пример демонстрации
Поскольку он предназначен для «продолжения точки останова» файлов, очевидно, что мы сначала создадим файл. Может быть, аудиофайлы, файлы изображений и т. Д. Будут выглядеть немного более стильно.
Но мы уже сказали, что в глазах крупных компьютерных братьев они в конечном итоге вернутся к «бинарному». Таким образом, мы создадим здесь простой файл «TXT», потому что TXT более благоприятно для понимания.
Мы создаем файл с именем «test.txt» в корневом каталоге диска D. Содержание файла очень прост, как показано на рисунке:
Это верно, то, что мы набрали, - это 6 простых английских букв. Затем мы щелкаем правой кнопкой мыши → свойства:
Мы видим, что файл сейчас составляет 6 байтов по размеру. Вот почему мы говорим, что все неотделимо от «бинарного».
Да, мы все понимаем, потому что мы вошли в 6 английских букв, а место для хранения, которое будет занять 1 английское письмо, составляет 1 байт (то есть 8 бит).
До сих пор то, что мы видели, скучно, потому что это в основном чепуха, и люди с небольшим количеством компьютерных знаний знают эти знания. Не волнуйся, давай продолжим.
Легко читать и написать файл в Java. Предположим, что текущее требование - «напишите этот файл с диска D, чтобы диск E», затем мы поднимаем клавиатуру и сделаем это!
Но разве так называемый «загрузка (загрузка)» так называемого файла? Единственное отличие состоит в том, что поведение меняется от «только между коренными жителями» к «между коренными жителями» на «между коренными жителями», чтение и написание файлов.
В настоящее время мы скажем: «Перестань настаивать, все знают эти вещи, как насчет« точки непрерывной передачи »?» На самом деле, это уже очень просто здесь. Мы еще раз дадим понять, что нам нужно сделать в точке перерыва, непрерывная передача:
Если в предыдущем поведении чтения и записи происходит прерывание, пожалуйста, запишите информацию о местонахождении содержимого файла, которое было прочитано и написано на этот раз; Когда «продолжение начинается», непосредственно переместите указатель здесь и начните продолжать операцию чтения и записи.
Повторный акцент на принципе на самом деле связан с тем, что до тех пор, пока принцип понимается, остальное просто движется. Это похоже на то, что «девять девять возвращения к одному» дхарме в романах боевых искусств, самый высокий уровень - вернуться к первоначальному источнику.
Пока мы понимаем принцип любой сложной вещи, мы можем лишить его и уменьшить его до простых вещей. Точно так же серия простых вещей, посредством логической комбинации, формируют сложные вещи.
Далее мы скоро вернемся в хаос и имитируем «непрерывную передачу точки» в самой основной форме. Здесь мы даже не пишем код сервера, и мы просто делаем это через локальный тестовый класс.
Эффект, который мы хотим достичь, очень прост: напишите файл «test.txt» на диске D на диск E, но мы имитируем поведение «прерывания» в середине процесса, а затем продолжим загружать снова, чтобы наконец завершить весь процесс.
Другими словами, мы будем рассматривать «D Drive» здесь как компьютер и напрямую рассматривать «E -диск» как сервер. Тогда нам больше не придется иметь отношение к протоколу HTTP в течение половины цента (конечно, мы все равно должны быть связаны с ним в реальной разработке), поэтому мы заботимся только о самых основных принципах «нарушения» и «продолжения» для чтения и написания файлов.
Чтобы углубить наше понимание с помощью сравнения, мы сначала пишем обычный кусок кода, то есть читать и писать обычно без перерыва:
открытый тест класса {public static void main (string [] args) {// source и target files file sourcefile = new File ("d:/", "test.txt"); File targetfile = new File ("e:/", "test.txt"); // Ввод и выходной поток FileInputStream fis = null; FileOutputStream fos = null; // байт буфера данных [] buf = new Byte [1]; try {fis = new FileInputStream (SourceFile); fos = new FileOutputStream (TargetFile); // Читать и записать данные while (fis.read (buf)! = -1) {System.out.println ("Записать данные ..."); fos.write (buf); }} catch (filenotFoundException e) {System.out.println ("Указанный файл не существует"); } catch (ioException e) {// todo: обрабатывать исключение} наконец {try {// закройте входной и выходной поток if (fis! = null) fis.close (); if (fos! = null) fos.close (); } catch (ioException e) {e.printstackTrace (); }}}} Когда этот код будет запущен, мы обнаружим, что копия «test.txt» была успешно скопирована на Disk E. Этот код очень проста, единственное, что можно сказать:
Мы видим, что мы устанавливаем BUF, то есть размер буфера равен 1, что фактически означает, что каждый раз, когда мы читаем, мы читаем байт данных (то есть 1 Английская буква).
Теперь давайте смоделируем поведение прерываний чтения и записи. Мы усовершенствоваем предыдущий код следующим образом:
Импорт java.io.file; импорт java.io.fileinputstream; импорт java.io.filenotfoundexception; import java.io.fileOutputStream; импорт java.io.ioexception; импорт java.io.randomaccessfile; public cest test {private int position = -1; public static void main (string [] args) {// источник и целевые файлы файл sourcefile = new File ("d:/", "test.txt"); File targetfile = new File ("e:/", "test.txt"); // Ввод и выходной поток FileInputStream fis = null; FileOutputStream fos = null; // байт буфера данных [] buf = new Byte [1]; try {fis = new FileInputStream (SourceFile); fos = new FileOutputStream (TargetFile); // Данные чтение и запись while (fis.read (buf)! = -1) {fos.write (buf); // Когда были загружены 3 байта содержимого файла, сеть прерывает и исключение брошено в if (targetfile.length () == 3) {position = 3; бросить новый FileCcessException (); }}} catch (fileCcessException e) {Keeping (SourceFile, TargetFile, Position); } catch (filenotFoundException e) {System.out.println ("Указание файла не существует"); } catch (ioException e) {// todo: обрабатывать исключение} наконец {try {// закройте входной и выходной поток if (fis! = null) fis.close (); if (fos! = null) fos.close (); } catch (ioException e) {e.printstackTrace (); }}} private static void hope (источник файла, цель файла, int position) {try {thread.sleep (10000); } catch (прерванная экспрессия e) {// todo автоматически сгенерированный блок e.printstacktrace (); } try {randomAccessfile Readfile = new randomAccessfile (Source, "rw"); Randomaccessfile writefile = new randomaccessfile (Target, "rw"); readfile.seek (позиция); writefile.seek (позиция); // байт буфера данных [] buf = new Byte [1]; // Данные чтение и запись while (readfile.read (buf)! = -1) {writefile.write (buf); }} catch (filenotfoundexception e) {// todo автоматически сгенерированный блок e.printstacktrace (); } catch (ioException e) {// todo автоматически сгенерированный блок e.printstacktrace (); }}} класс FileCcessException Exceptends exection {}Подводя итог, какую работу мы проделали в этом изменении:
• Сначала мы определяем позицию переменной для записи места, где чтение и запись была завершена, когда происходит прерывание. (Это для удобства. Фактически, следует сказать, что это значение следует хранить в файле или базе данных для постоянства)
• Затем в цикле чтения и написания файлов мы имитируем возникновение поведения прерывания. Здесь, когда длина файла целевого файла составляет 3 байта, он имитирует, что мы настраивали исключение. (Мы можем представить, что в реальной загрузке содержание байтов «x» было загружено (загружено), а сеть прерывается в настоящее время, поэтому мы записываем «X» в исключении, вызванном сетевым прерыванием).
• Остальное, как мы уже говорили ранее, после начала поведения «продолжения» мы обертываем наш файл через класс randomaccessfile, а затем указываем указатель на местоположение, где предыдущее прерывание произошло для чтения и написания через поиск.
(Для фактической загрузки и загрузки файлов, конечно, нам нужно загрузить сохраненное значение прерывания на сервер. Этот метод обычно является httpconnection.setrequestproperty («range», «bytes = x»););););
В нашем коде, включите поведение «продолжения», то есть метод сохранения: мы начинаем позволять потоке спать в течение 10 секунд, что именно для того, чтобы позволить нам запустить программу и увидеть эффект.
Теперь, когда мы запускаем программу, файл запустит «процесс загрузки с D Disk в E -диск». Во -первых, мы нажимаем на диск E и обнаруживаем, что действительно есть дополнительный файл test.txt. Откройте его и найдите контент следующим образом:
Правильно, в настоящее время мы обнаружили, что содержание имеет только «ABC». Это в пределах наших ожиданий, потому что наша программа прерывается, когда файл загружается 3 байтами.
Хорошо, давайте спокойно подождем 10 секунд, а затем нажмите на файл, чтобы увидеть, может ли он добиться успеха:
Благодаря скриншотам мы обнаружили, что содержание действительно стало «ABC», и, таким образом, продолжение было завершено.
Выше всего содержание этой статьи. Я надеюсь, что это будет полезно для каждого обучения, и я надеюсь, что все будут поддерживать Wulin.com больше.