Prinzipanalyse
Während der Entwicklung ist die Funktion von "Breakpoint Continuous Transmission" sehr praktisch und häufig und klingt auch "Standard". Wir sind also normalerweise daran interessiert, zu untersuchen, wie diese Funktion implementiert wird?
In Java finden Sie auch viele Informationen über die Implementierung ähnlicher Funktionen im Internet. Die meisten von ihnen geben jedoch eine Demo an und veröffentlichen den Quellcode. Es gibt nur sehr wenige detaillierte Erklärungen für das Implementierungsprinzip.
Als wir also zum ersten Mal in Kontakt kamen, verwenden wir möglicherweise direkt CRTL + C/V -Codes und basteln dann daran, aber wir können endlich den Effekt herausholen. Aber wenn Sie Anfänger sind, ist offensichtlich gut und schlecht.
Der Vorteil ist, dass es viele Quellcodes und wenige Erklärungen gibt. Wenn wir bereit sind, hart zu arbeiten, werden wir nach Informationen suchen und die Dinge studieren, die wir in dem von anderen veröffentlichten Code nicht verstehen. Am Ende werden Sie wahrscheinlich viele Belohnungen bekommen.
Die Nachteile sind auch offensichtlich: Als Anfänger ist es, als ob viele Dinge unbekannt sind, so dass es leicht ist, entmutigt zu werden. Auch wenn Sie am Ende ein grobes Verständnis für die Verwendung haben, verstehen Sie das Implementierungsprinzip möglicherweise nicht unbedingt.
Beginnen wir heute aus der grundlegendsten Perspektive und sehen, ob die sogenannte „Haltepunkt-Fortsetzung“ wirklich so „High-End“ ist.
Wenn Sie mit einem neuen "Ding" in Kontakt kommen, können Sie es in etwas verwandeln, mit dem wir uns besser beziehen und vergleichen und lernen können. Normalerweise wird es mit der halben Anstrengung doppelt so hoch wie die Hälfte.
Wenn wir nur dem Konzept der "Breakpoint Continuous Getriebe" ausgesetzt sind, wird es definitiv schwierig sein, eindeutig ein, zwei und drei zu erklären. Dann werden wir auf jeden Fall mit "Spielen" vertraut sein.
OK, dann nehmen wir an, wir haben jetzt ein "Clear-Level-RPG-Spiel". Denken Sie darüber nach, was wir normalerweise tun, wenn wir diese Art von Spiel spielen?
Es ist offensichtlich, dass wir am ersten Tag blutige Schlachten kämpften und alle getötet haben, vorausgesetzt, wir kamen endlich auf der vierten Ebene an. Obwohl der heftige Kampf in vollem Gange war, als ich die Uhr an der Wand betrachtete, war es bereits 12 Uhr morgens und es war Zeit, ins Bett zu gehen.
Es war zu dieser Zeit sehr peinlich. Was sollten wir tun, um mit dem Fortschritt unseres Spiels das nächste Mal erfolgreich Schritt zu halten?
Es ist sehr einfach. Wir schalten das Spiel nicht aus, wir gehen ins Bett und spielen am nächsten Tag weiter. Das ist in Ordnung, aber es scheint, dass es etwas gibt, das die Menschen unwohl fühlen lässt.
Wenn das Spiel zu diesem Zeitpunkt eine Funktion namens "Save" hat, wird es sehr wichtig sein. Wir wählen direkt das Archiv aus, geben den Archivnamen "viertes Level" ein und können dann das Spiel schließen.
Wenn wir das Spiel beim nächsten Mal spielen, werden wir direkt den "vierten Level" speichern und dann die Datei lesen und dann das Spiel weiter spielen.
Zu diesem Zeitpunkt ist der sogenannte "Breakpoint Continuous Getriebe" leicht zu verstehen. Folgen wir unserer früheren Idee, "Spiele zu spielen":
Angenommen, es gibt eine Datei, die wir jetzt herunterladen müssen. Wenn wir einen Teil davon herunterladen, tritt eine Situation auf, wie z.
Tatsächlich war dies so, als würden wir zuvor Spiele gespielt, wir mussten plötzlich ins Bett gehen und um 12 Uhr ruhen. Ok, dann ist die Situation zu dieser Zeit:
• Wenn das Spiel nicht gerettet werden kann, bedeutet dies, dass beim nächsten Spielen der Fortschritt der 4 Levels, die diesmal vergangen sind, verloren gehen und wir dem Spiel nicht folgen können.
• Entsprechend kann, wenn das Verhalten "Download" einen Fortschritt dieses Downloads nicht aufzeichnen kann. Wenn wir diese Datei erneut herunterladen, können wir nur von vorne beginnen.
Zu diesem Zeitpunkt haben wir tatsächlich entdeckt, dass der Schlüssel zu dem oben erwähnten Verhalten das Wort " Weiter " ist!
Um den Zweck zu erreichen, ein getrenntes Verhalten zu "fortsetzen", besteht der Schlüssel darin, dass ein "Medien" die Informationen des Knotens aufzeichnen und lesen kann, bei dem das Verhalten eine "Unterbrechung" hat.
Verwandeln sich in die Programmierwelt
Tatsächlich ist dies das grundlegendste Prinzip der "Breakpoint Continuous Getriebe". In einfachen Worten müssen wir die Interrupt -Standortinformationen aufzeichnen, wenn das Download -Verhalten unterbrochen wird, und sie dann im nächsten Verhalten lesen.
Überlegen Sie sich mit diesen Standortinformationen darüber, was wir tun sollten. Ja, es ist sehr einfach. Wenn ein neues Download -Verhalten beginnt, laden Sie Inhalte direkt von diesem Ort des Datensatzes herunter und beginnt nicht mehr von vorne.
Nun, wir haben über das Prinzip der so lange in einfachen Sprache gesprochen und uns gelangweilt gefühlt. Fassen wir es also am Ende zusammen und schauen uns dann an, wie wir die Prinzipien in die Programmierwelt umwandeln sollten.
• Wenn das Verhalten "Upload (Download)" unterbrochen wird, müssen wir den Ort (Position) dieses Uploads (Download) aufzeichnen.
• Wenn das Verhalten "Fortsetzung" beginnt, springen wir direkt zum Post, um weiter hochzuladen (Herunterladen).
Offensichtlich liegt der Schlüssel zum Problem in der sogenannten "Position". Im "Passing Level Game", das wir erwähnten, kann "Welches Level" als Einheit dieser Position verwendet werden.
Wenn wir also in die sogenannte "Breakpoint-kontinuierliche Übertragung" wechseln, was sollten wir dann verwenden, um die "Position" zu messen? Offensichtlich ist es wieder binär, weil die Essenz hier nichts anderes ist, als Dateien zu lesen und zu schreiben.
Dann ist der Rest der Arbeit sehr einfach. Ernen Sie zunächst die Position, die nichts zu sein scheint, über das es sich zu sprechen scheint, denn es ist nur die Persistenz von Daten (Speicher, Dateien, Datenbank) und wir haben viele Möglichkeiten.
Ein weiterer Schlüssel ist, dass wir beim Start des "Fortsetzung" -Vortiers die Lese- und Schreiben von Operationen aus der Position, die wir beim letzten Mal aufgezeichnet haben, starten müssen, also brauchen wir etwas Ähnliches wie die Funktion "Zeiger".
Natürlich können wir auch einen Weg finden, einen solchen "Zeiger" zu implementieren, aber froh, dass Java uns eine solche Klasse zur Verfügung gestellt hat, dh randomAccessfile.
Die Funktion dieser Klasse spiegelt sich intuitiv in ihrem Namen wider und kann zufällig auf Dateien zugreifen. Schauen wir uns die Beschreibung dieser Klasse in der API -Dokumentation an:
Instanzen dieser Klasse unterstützen und schreiben in zufällig zu aufgerufenen Dateien. Der zufällige Zugriff auf Dateien verhält sich wie ein im Dateisystem gespeicherter großer Byte -Array.
Wenn auf eine Datei im Lese-/Schreibmodus zufällig zugegriffen wird, ist auch der Ausgabebetrieb verfügbar. Die Ausgabeoperation beginnt mit dem Dateizeiger und fördert den Dateizeiger, wenn das Byte geschrieben ist.
Ein Ausgangsvorgang nach dem Schreiben an das aktuelle Ende eines impliziten Arrays veranlasst das Array. Der Dateizeiger kann die GetFilePointer -Methode durchlesen und die Suchmethode durchgesetzt werden.
Nachdem wir die API -Anweisungen gelesen hatten, lachten wir. Ja, ist das nicht genau das, was wir wollen? Nun, wir haben unser Messer so lange geschärft, warum hacken wir kein Holz?
Beispieldemonstration
Da es sich um die "Breakpoint -Fortsetzung" von Dateien handelt, ist es offensichtlich, dass wir zuerst eine Datei erstellen. Vielleicht sehen Audiodateien, Bilddateien usw. etwas edler aus.
Aber wir haben bereits gesagt, dass sie in den Augen der großen Computerbrüder irgendwann zu "binär" zurückkehren werden. Wir werden hier also eine einfache "TXT" -Datei erstellen, da TXT dem Verständnis förderlicher ist.
Wir erstellen eine Datei mit dem Namen "test.txt" im Stammverzeichnis der Festplatte D. Der Dateiinhalt ist sehr einfach, wie in der Abbildung gezeigt:
Das stimmt, was wir eingegeben haben, sind 6 einfache englische Buchstaben. Dann klicken wir mit der rechten Maustaste → Eigenschaften:
Wir sehen, dass die Datei jetzt 6 Bytes groß ist. Deshalb sagen wir, dass alles untrennbar mit "Binär" unzertrennlich ist.
Ja, wir alle verstehen, weil wir 6 englische Buchstaben eingetragen haben und der Speicherplatz, den 1 englischer Brief besetzt, 1 Byte (d. H. 8 Bit) ist.
Bisher ist das, was wir gesehen haben, langweilig, weil dies im Grunde genommen Unsinn ist und Menschen mit ein wenig Computerwissen dieses Wissen kennen. Mach dir keine Sorgen, lass uns weitermachen.
Es ist einfach, eine Datei in Java zu lesen und zu schreiben. Angenommen, die aktuelle Anforderung lautet "Schreiben Sie diese Datei vom Laufwerk D zum Laufwerk E", dann heben wir die Tastatur an und erledigen sie!
Aber ist der sogenannte "Upload (Download)" der sogenannten Datei nicht? Der einzige Unterschied besteht darin, dass sich das Verhalten von "nur zwischen Eingeborenen" zu "zwischen Eingeborenen" zu "zwischen Eingeborenen" -Datei -Lesen und -geschrieben ändert.
Zu diesem Zeitpunkt werden wir sagen: "Hör auf zu drängen, jeder weiß diese Dinge, was ist mit 'Breakpoint Continuous Getriebe'?" Tatsächlich ist es hier schon sehr einfach. Wir werden erneut klarstellen, dass das, was wir in der kontinuierlichen Übertragung von Haltepunkten tun müssen, lautet:
Wenn es im vorherigen Lesen und Schreibverhalten eine Unterbrechung gibt, zeichnen Sie bitte die Standortinformationen des Dateiinhalts auf, die diesmal gelesen und schreiben. Wenn "Fortsetzung beginnt", verschieben Sie den Zeiger direkt hier und beginnen Sie mit dem Lese- und Schreibvorgang fortzusetzen.
Die wiederholte Betonung des Prinzips liegt tatsächlich daran, dass der Rest nur bewegt ist, solange das Prinzip verstanden wird. Dies ist genau wie die "Nine Nine Return to One" Dharma in Kampfkunstromanen. Die höchste Ebene besteht darin, zur ursprünglichen Quelle zurückzukehren.
Solange wir das Prinzip aller komplexen Sache verstehen, können wir es wegziehen und auf einfache Dinge reduzieren. In ähnlicher Weise bilden eine Reihe einfacher Dinge durch logische Kombination komplexe Dinge.
Als nächstes werden wir bald ins Chaos zurückkehren und eine "Breakpoint -kontinuierliche Übertragung" in der grundlegendsten Form simulieren. Hier schreiben wir nicht einmal den Servercode und machen ihn einfach über eine lokale Testklasse.
Der Effekt, den wir erreichen möchten, ist sehr einfach: Schreiben Sie die Datei "test.txt" auf der Festplatte zu Festplatte E, aber wir werden das Verhalten "Interrupt" in der Mitte des Prozesses simulieren und dann weiterhin erneut hochladen, um den gesamten Prozess endgültig zu vervollständigen.
Mit anderen Worten, wir werden "D Drive" als Computer hier betrachten und "E Drive" als Server direkt betrachten. Dann werden wir einen halben Cent nicht mehr mit dem HTTP -Protokoll zu tun haben (natürlich müssen wir in der tatsächlichen Entwicklung immer noch damit zu tun haben), daher kümmern wir uns nur um die grundlegendsten Prinzipien des "Brechens" und "Fortsetzung" für das Lesen und Schreiben von Dateien.
Um unser Verständnis durch Vergleich zu vertiefen, schreiben wir zunächst einen normalen Code, dh, lesen und schreiben normal ohne Unterbrechung:
public class test {public static void main (String [] args) {// Quell- und Zieldatei Datei SourceFile = new Datei ("d:/", "test.txt"); Datei targetFile = new Datei ("e:/", "test.txt"); // Eingabe- und Ausgabe von Stream FileInputStream fis = null; FileOutputStream fos = null; // Datenpuffer Byte [] buf = neues Byte [1]; try {fis = new FileInputStream (SourceFile); fos = new FileOutputStream (TargetFile); // Daten lesen und schreiben, wobei (fis.read (buf)! = -1) {System.out.println ("Daten schreiben ..."); fos.write (buf); }} catch (FilenotFoundException e) {System.out.println ("angegebene Datei existiert nicht"); } catch (ioException e) {// Todo: Handle -Ausnahme} endlich {try {// den Eingangs- und Ausgabestream schließen, wenn (fis! = null) fis.close (); if (fos! = null) fos.close (); } catch (ioException e) {e.printstacktrace (); }}}} Wenn dieser Code ausgeführt wird, werden wir feststellen, dass eine Kopie von "test.txt" erfolgreich in der Festplatte E kopiert wurde. Dieser Code ist sehr einfach. Das einzige, was zu sagen ist, ist:
Wir sehen, dass wir den BUF festlegen, dh die Größe des Puffers ist 1, was tatsächlich bedeutet, dass wir jedes Mal, wenn wir lesen, ein Datenbyte lesen (d. H. 1 englischer Buchstaben).
Lassen Sie uns nun das Verhalten von Lesen und Schreiben von Interrupts simulieren. Wir werden den vorherigen Code wie folgt perfektionieren:
import Java.io.file; import java.io.fileinputstream; import java.io.filenotFoundException; importieren java.io.fileoutputStream; import Java.io.ioException; import Java.io.randomaccessfile; Public Class Test {private static intposition = -1; public static void main (String [] args) {// Quell- und Zieldatei -Datei SourceFile = new Datei ("d:/", "test.txt"); Datei targetFile = new Datei ("e:/", "test.txt"); // Eingabe- und Ausgabe von Stream FileInputStream fis = null; FileOutputStream fos = null; // Datenpuffer Byte [] buf = neues Byte [1]; try {fis = new FileInputStream (SourceFile); fos = new FileOutputStream (TargetFile); // Daten lesen und schreiben, wobei (fis.read (buf)! = -1) {fos.write (buf); // Wenn 3 Bytes von Dateiinhalten hochgeladen wurden, wird das Netzwerk unterbrechen und eine Ausnahme wird ausgelöst, wenn (targetFile.length () == 3) {Position = 3; neue fileAccessException () werfen; }}} catch (fileAccessException e) {Keepogou (SourceFile, TargetFile, Position); } catch (FilenotFoundException e) {System.out.println ("Datei angeben nicht existiert"); } catch (ioException e) {// Todo: Handle -Ausnahme} endlich {try {// den Eingangs- und Ausgabestream schließen, wenn (fis! = null) fis.close (); if (fos! = null) fos.close (); } catch (ioException e) {e.printstacktrace (); }}} private static void keepoing (Dateiquelle, Dateiziel, int Position) {try {Thread.sleep (10000); } catch (InterruptedException e) {// Todo automatisch generierter Catch-Block e.printstacktrace (); } try {randomAccessfile readFile = new randomAccessfile (Quelle, "rw"); RandomAccessfile writeFile = new randomAccessfile (Ziel, "rw"); ReadFile.seek (Position); writeFile.seek (Position); // Datenpuffer Byte [] buf = neues Byte [1]; // Daten lesen und schreiben whil while (readFile.read (buf)! = -1) {writeFile.write (buf); }} catch (FilenotFoundException e) {// todo automatisch generiertes Catch-Block e.printstacktrace (); } catch (ioException e) {// Todo automatisch generierter Catch-Block e.printstacktrace (); }}} class fileAcessException erweitert die Ausnahme {}Zusammenfassend, welche Arbeit wir in dieser Änderung geleistet haben:
• Zunächst definieren wir eine variable Position, um den Ort aufzuzeichnen, an dem Lese- und Schreiben abgeschlossen wurde, wenn ein Interrupt auftritt. (Dies dient der Bequemlichkeit. Tatsächlich sollte gesagt werden, dass dieser Wert in einer Datei oder Datenbank für Persistenz gespeichert werden sollte.)
• Dann simulieren wir in der WHHE -Schleife des Dateilesens und des Schreibens das Auftreten eines Interruptverhaltens. Wenn die Dateilänge der Targetfile 3 Bytes beträgt, simuliert sie eine Ausnahme, die wir angepasst haben. (Wir können uns vorstellen, dass im tatsächlichen Download der Inhalt von "X" -Bytes hochgeladen wurde (heruntergeladen) und das Netzwerk zu diesem Zeitpunkt unterbrochen wird, sodass wir "X" in der Ausnahme des Netzwerks Interrupt aufzeichnen.)
• Der Rest ist, wie wir bereits gesagt haben, nachdem das "Fortsetzung" Verhalten unsere Datei durch die RandomAccessfile -Klasse wickeln und dann den Zeiger an den Ort angeben, an dem der vorherige Interrupt zum Lesen und Schreiben durch Such stattgefunden hat.
(Für die tatsächlichen Datei herunterladen und hochladen, müssen wir natürlich den gespeicherten Interrupt -Wert auf den Server hochladen. Diese Methode ist normalerweise httpConnection.setRequestProperty ("Bereich", "bytes = x");)
Aktivieren Sie in unserem Code das "fortgesetzte" Verhalten, dh die Anhaltungsmethode: Wir lassen den Thread 10 Sekunden lang schlafen, was genau dazu dient, das Programm durchzuführen und den Effekt zu sehen.
Nachdem wir das Programm ausführen, startet die Datei den "Prozess des Hochladens von D -Disk zu E -Disk". Zunächst klicken wir auf die E -Festplatte und stellen fest, dass es tatsächlich eine zusätzliche Test.txt -Datei gibt. Öffnen Sie es und finden Sie den Inhalt wie folgt:
Das ist richtig, zu diesem Zeitpunkt stellten wir fest, dass der Inhalt nur "ABC" hat. Dies liegt in unseren Erwartungen, da unsere Programmsimulation unterbrochen wird, wenn die Datei von 3 Bytes hochgeladen wird.
OK, lasst uns 10 Sekunden lang ruhig warten, um zu bestehen, und klicken Sie dann auf die Datei, um festzustellen, ob sie erfolgreich sein kann:
Durch Screenshots stellten wir fest, dass der Inhalt tatsächlich zu "ABC" geworden ist und daher die Fortsetzung abgeschlossen wurde.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.