Análisis de principios
Durante el desarrollo, la función de la "transmisión continua del punto de interrupción" es muy práctica y común, y también suena más "estándar". ¿Entonces generalmente estamos interesados en estudiar cómo se implementa esta función?
En Java, también puede encontrar mucha información sobre la implementación de funciones similares en Internet. Sin embargo, la mayoría de ellos dan una demostración y publican el código fuente. Hay muy pocas explicaciones detalladas para su principio de implementación.
Entonces, cuando entramos en contacto por primera vez con él, podríamos usar directamente los códigos CRTL + C/V y luego jugar con él, pero finalmente podemos obtener el efecto. Pero hacer esto cuando eres principiante es obviamente bueno y malo.
La ventaja es que hay muchos códigos fuente y pocas explicaciones; Si estamos dispuestos a trabajar duro, buscaremos información y estudiaremos las cosas que no entendemos en el código publicado por otros. Al final, probablemente obtendrá muchas recompensas.
Las desventajas también son obvias: como principiante, cuando se enfrenta a un montón de código fuente, parece que muchas cosas no son familiares, por lo que es fácil ser intimidado. Incluso si tiene una comprensión aproximada del uso al final, es posible que no necesariamente comprenda el principio de implementación.
Hoy, comencemos desde la perspectiva más básica y veamos si la llamada "continuación del punto de interrupción" es realmente tan "de alta gama".
De hecho, cuando entra en contacto con una nueva "cosa", puede transformarlo en algo con lo que estamos más familiarizados para referirnos y comparar y aprender. Por lo general, será el doble del resultado con la mitad del esfuerzo.
Si solo estamos expuestos al concepto de "transmisión continua de punto de ruptura", definitivamente será difícil explicar claramente uno, dos y tres. Entonces, definitivamente estaremos familiarizados con "jugar juegos".
Ok, entonces supongamos que ahora tenemos un "juego de juegos de rol de nivel claro". ¿Piensas en lo que solemos hacer cuando jugamos este tipo de juego?
Es obvio que el primer día luchamos con las sangrientas batallas y matamos a todos, suponiendo que finalmente llegamos al cuarto nivel. Aunque la feroz batalla estaba en pleno apogeo, cuando miré el reloj en la pared, ya eran las 12 a.m. y era hora de acostarse.
Fue muy vergonzoso en este momento. Para mantener con éxito el ritmo del progreso de nuestro juego la próxima vez que jugemos, ¿qué debemos hacer?
Es muy simple. No apagamos el juego, nos acostamos y seguimos jugando al día siguiente. Esto está bien, pero parece que hay algo que hace que las personas se sientan incómodas.
Entonces, en este momento, si el juego tiene una función llamada "Guardar", será muy importante. Seleccionamos directamente el archivo, ingresamos el nombre del archivo "Cuarto nivel", y luego podemos cerrar el juego.
Cuando jugemos el juego la próxima vez, encontraremos directamente el guardado del "Cuarto nivel", luego leeremos el archivo y luego podemos continuar jugando el juego.
En este momento, la llamada "transmisión continua del punto de interrupción" es fácil de entender. Seguimos nuestra idea anterior de "jugar juegos":
Supongamos que hay un archivo que necesitamos descargar ahora. Cuando descargamos parte de ella, se produce una situación, como: la computadora se bloquea, la potencia está fuera, la red se interrumpe, etc.
De hecho, esto es como cuando estábamos jugando antes, de repente necesitábamos ir a la cama y descansar a las 12 en punto. Ok, entonces la situación en este momento es:
• Si el juego no se puede guardar, significa que la próxima vez que jugemos, el progreso de los 4 niveles que hayan pasado esta vez se perderá y no podemos seguir el juego.
• En consecuencia, si el comportamiento de "descargar" no puede registrar un progreso de esta descarga. Luego, cuando descargamos este archivo nuevamente, solo podemos comenzar de nuevo.
¡En este punto, hemos descubierto que la clave del comportamiento que mencionamos anteriormente es la palabra " Continuar "!
Para lograr el propósito de "continuar" un comportamiento desconectado, la clave es tener un "medio" capaz de grabar y leer la información del nodo donde el comportamiento tiene una "interrupción".
Transformarse en el mundo de la programación
De hecho, este es el principio más básico de la "transmisión continua del punto de interrupción". En palabras simples, necesitamos registrar la información de ubicación de interrupción cuando se interrumpe el comportamiento de descarga y luego la leer en el siguiente comportamiento.
Con esta información de ubicación, piense en lo que debemos hacer. Sí, es muy simple. Cuando comience un nuevo comportamiento de descarga, descargue contenido directamente desde esta ubicación del registro y ya no se inicia desde cero.
Bueno, hemos estado hablando del principio de tanto tiempo en lenguaje sencillo y comenzamos a sentirse aburridos. Así que resumamos al final y luego echemos un vistazo a cómo debemos convertir los principios en el mundo de la programación.
• Cuando se interrumpe el "comportamiento de carga (descargar)", necesitamos grabar la ubicación (posición) de esta carga (descargar).
• Cuando comienza el comportamiento de "continuar", saltamos directamente a la publicación para continuar cargando (descarga).
Obviamente, la clave del problema radica en la llamada "posición". En el "Juego de nivel de pase" mencionamos ", qué nivel" se puede usar como la unidad de esta posición.
Entonces, cuando cambiamos a la llamada "transmisión continua del punto de interrupción", ¿qué debemos usar para medir la "posición"? Obviamente, ha vuelto a Binary porque la esencia aquí no es más que leer y escribir archivos.
Entonces el resto del trabajo es muy simple. Primero, registre la posición, que no parece ser nada de la que valga la pena hablar, porque es solo la persistencia de los datos (memoria, archivos, base de datos), y tenemos muchas maneras.
Otra clave es que cuando comienza el comportamiento "continuo", necesitamos iniciar las operaciones de lectura y escritura desde la posición de posición que registramos la última vez, por lo que necesitamos algo similar a la función "Pointer".
Por supuesto, también podemos encontrar una manera de implementar un "puntero", pero felices de que Java nos haya proporcionado una clase de este tipo, es decir, RandomAccessfile.
La función de esta clase se refleja intuitivamente en su nombre, y puede acceder a los archivos al azar. Echemos un vistazo a la descripción de esta clase en la documentación de la API:
Las instancias de esta clase admiten leer y escribir a archivos de acceso aleatorio. El acceso aleatorio a los archivos se comporta como una gran matriz de bytes almacenada en el sistema de archivos.
Si se accede a un archivo al azar en modo de lectura/escritura, la operación de salida también está disponible; La operación de salida comienza con el puntero del archivo y avanza el puntero del archivo a medida que se escribe el byte.
Una operación de salida después de escribir hasta el extremo actual de una matriz implícita hace que la matriz se expanda. El puntero del archivo se puede leer a través del método getFilePointer y establecer el método Seek.
Después de leer las instrucciones de la API, nos reímos. Sí, ¿no es esto exactamente lo que queremos? Bueno, hemos estado afilando nuestro cuchillo durante tanto tiempo, ¿por qué no cortamos madera?
Demostración de ejemplo
Dado que es para la "continuación de punto de interrupción" de los archivos, es obvio que primero crearemos un archivo. Tal vez archivos de audio, archivos de imagen, etc. se verán un poco más elegantes.
Pero ya hemos dicho que a los ojos de los Big Computer Brothers, eventualmente volverán al "binario". Por lo tanto, crearemos un archivo simple "txt" aquí, porque TXT es más propicio para la comprensión.
Creamos un archivo llamado "test.txt" en el directorio raíz del disco D. El contenido del archivo es muy simple, como se muestra en la figura:
Así es, lo que escribimos son 6 letras simples en inglés. Luego hacemos clic derecho → Propiedades:
Vemos que el archivo ahora tiene un tamaño de 6 bytes. Es por eso que decimos que todo es inseparable de "binario".
Sí, todos entendemos porque ingresamos 6 letras inglesas, y el espacio de almacenamiento que ocupará la letra inglesa es de 1 byte (es decir, 8 bits).
Hasta ahora, lo que hemos visto es aburrido, porque esto es básicamente sin sentido, y las personas con un poco de conocimiento informático conocen este conocimiento. No te preocupes, continuemos.
Es fácil de leer y escribir un archivo en Java. Supongamos que el requisito actual es "Escriba este archivo desde la unidad D a la unidad E", ¡luego levantaremos el teclado y lo haremos!
Pero, ¿no es el llamado "Carga (descarga)" del llamado archivo? La única diferencia es que el comportamiento cambia de "solo entre nativos" a "entre nativos" a "entre nativos" lectura de archivos y escritura.
En este momento, diremos: "Deja de instar, todos saben estas cosas, ¿qué pasa con la 'transmisión continua del punto de interrupción'?" De hecho, ya es muy simple aquí. Dejaremos en claro nuevamente que lo que debemos hacer en la transmisión continua de punto de interrupción es:
Si hay una interrupción en el comportamiento anterior de lectura y escritura, registre la información de ubicación del contenido del archivo que se ha leído y escribe esta vez; Cuando "comience la continuación", mueva directamente el puntero aquí y comience a continuar la operación de lectura y escritura.
El énfasis repetido en el principio se debe a que mientras se entienda el principio, el resto se mueve. Esto es al igual que el "nueve nueve regreso a un" dharma en las novelas de artes marciales, el nivel más alto es volver a la fuente original.
Mientras entendamos el principio de cualquier cosa compleja, podemos quitarlo y reducirlo a cosas simples. Del mismo modo, una serie de cosas simples, a través de una combinación lógica, forman cosas complejas.
A continuación, volveremos al caos pronto y simularemos una "transmisión continua de punto de interrupción" en la forma más básica. Aquí ni siquiera escribimos el código del servidor, y lo hacemos a través de una clase de prueba local.
El efecto que queremos lograr es muy simple: escriba el archivo "test.txt" en el disco D al disco E, pero simularemos el comportamiento de "interrupción" en el medio del proceso y luego continuaremos cargando nuevamente para finalmente completar todo el proceso.
En otras palabras, consideraremos la "unidad D" como una computadora aquí, y consideraremos directamente la "unidad E" como servidor. Entonces ya no tendremos que ver con el protocolo HTTP durante medio centavo (por supuesto, aún debemos tener que ver con él en el desarrollo real), por lo que solo nos importan los principios más básicos de "romper" y "continuar" para leer y escribir archivos.
Para profundizar nuestra comprensión a través de la comparación, primero escribimos una pieza de código normal, es decir, leer y escribir normalmente sin interrupción:
Public Class Test {public static void main (string [] args) {// Fuente y archivos Archivos de archivos SourceFile = new File ("d:/", "test.txt"); Archivo TargetFile = nuevo archivo ("e:/", "test.txt"); // flujo de entrada y salida fileInputStream fis = null; FileOutputStream fos = null; // buffer de datos byte [] buf = new Byte [1]; intente {fis = new FileInputStream (SourceFile); fos = nuevo FileOutputStream (TargetFile); // leer y escribir datos mientras (fis.read (buf)! = -1) {system.out.println ("escribir datos ..."); fos.write (buf); }} Catch (FileNotFoundException e) {System.out.println ("El archivo especificado no existe"); } Catch (ioException e) {// tODO: manejar excepción} Finalmente {try {// cierre el flujo de entrada y salida if (fis! = null) fis.close (); if (fos! = null) fos.close (); } catch (ioException e) {E.PrintStackTrace (); }}}} Cuando se ejecuta este código, encontraremos que una copia de "Test.txt" se ha copiado con éxito en el disco E. Este código es muy simple, lo único que se debe decir es:
Vemos que establecemos el BUF, es decir, el tamaño del búfer es 1, lo que en realidad significa que cada vez que leemos, leemos un byte de datos (es decir, 1 letra en inglés).
Ahora, simulemos el comportamiento de las interrupciones de lectura y escritura. Perfeccionaremos el código anterior de la siguiente manera:
import java.io.file; import java.io.fileinputstream; import java.io.filenotfoundexception; import java.io.fileOutputStream; import java.io.ioexception; import java.io.randomaccessfile; prueba de clase pública {private estatic int public static void main (string [] args) {// Fuente y archivos de archivo Archivos FILEFILE = new File ("d:/", "test.txt"); Archivo TargetFile = nuevo archivo ("e:/", "test.txt"); // flujo de entrada y salida fileInputStream fis = null; FileOutputStream fos = null; // buffer de datos byte [] buf = new Byte [1]; intente {fis = new FileInputStream (SourceFile); fos = nuevo FileOutputStream (TargetFile); // Datos lee y escribe mientras (fis.read (buf)! = -1) {fos.write (buf); // Cuando se han cargado 3 bytes de contenido de archivo, la red interrumpe y se lanza una excepción si (TargetFile.Length () == 3) {Position = 3; tirar nueva FileAccessException (); }}} Catch (FileAccessException e) {Keepurging (SourceFile, TargetFile, Position); } Catch (FileNotFoundException e) {System.out.println ("Especificar el archivo no existe"); } Catch (ioException e) {// tODO: manejar excepción} Finalmente {try {// cierre el flujo de entrada y salida if (fis! = null) fis.close (); if (fos! = null) fos.close (); } catch (ioException e) {E.PrintStackTrace (); }}} private static void Keepurging (Fuente de archivo, Target de archivo, INT Position) {try {Thread.sleep (10000); } Catch (InterruptedException e) {// TODO Auto Generado Bloque E.PrintStackTrace (); } try {randomAccessFile readFile = new RandomAccessFile (fuente, "RW"); RandomAccessFile WriteFile = new RandomAccessFile (Target, "RW"); readfile.seek (posición); WriteFile.seek (posición); // buffer de datos byte [] buf = new Byte [1]; // Datos lee y escribe while (readFile.read (buf)! = -1) {writeFile.Write (buf); }} Catch (FileNotFoundException e) {// TODO BLOQUE DE CABTA AUTO GENERADA E.PRINTSTACKTRACE (); } Catch (ioException e) {// tODO Auto Generated BLOCK E.PrintStackTRace (); }}} La clase FileAccessException extiende la excepción {}En resumen, qué trabajo hicimos en este cambio:
• Primero, definimos una posición variable para registrar la ubicación donde se ha completado la lectura y la escritura cuando se produce una interrupción. (Esto es por conveniencia. De hecho, debe decirse que este valor debe almacenarse en un archivo o base de datos para su persistencia)
• Luego, en el bucle de lectura y escritura de archivos, simulamos la ocurrencia de un comportamiento de interrupción. Aquí, cuando la longitud del archivo de TargetFile es de 3 bytes, simula lanzar una excepción que personalizamos. (Podemos imaginar que en la descarga real, el contenido de "X" bytes se ha cargado (descargado) y la red se interrumpe en este momento, por lo que grabaremos "X" en la excepción lanzada por la interrupción de la red).
• El resto es como dijimos antes, después de que comienza el comportamiento de "continuación", envolvemos nuestro archivo a través de la clase RandomAccessFile y luego especificamos el puntero a la ubicación donde ocurrió la interrupción anterior para leer y escribir a través de la búsqueda.
(Para descargar y cargar archivos reales, por supuesto, necesitamos cargar el valor de interrupción guardado en el servidor. Este método generalmente es httpconnection.setRequestProperty ("rango", "bytes = x");)
En nuestro código, habilite el comportamiento "continuo", es decir, el método de mantenimiento: comenzamos a dejar que el hilo duerma durante 10 segundos, que precisamente nos permite ejecutar el programa y ver el efecto.
Ahora que ejecutamos el programa, el archivo iniciará el "proceso de carga desde el disco D al disco E". Primero, hacemos clic en el disco E y encontramos que de hecho hay un archivo Test.txt adicional. Ábrelo y busque el contenido de la siguiente manera:
Así es, en este momento descubrimos que el contenido solo tiene "ABC". Esto está dentro de nuestras expectativas, porque nuestra simulación de programa interrumpe cuando el archivo está cargado por 3 bytes.
OK, esperemos en silencio durante 10 segundos para pasar, y luego haga clic en el archivo para ver si puede tener éxito:
A través de las capturas de pantalla, encontramos que el contenido se ha convertido en "ABC" y, por lo tanto, se completó la continuación.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.