Con este método, puede empaquetar archivos al instante, transferirlos mientras empaquete, sin usar caché, ¡lo que permite a los usuarios esperar cero!
La copia del código es la siguiente:
/**
*
* Socador de clientes mysocket
* @param archivo la carpeta o archivo a empaquetarse
* @param nombre de archivo el nombre del archivo de la descarga empaquetada
* @throws ioexception
*/
Private void down (archivo de archivo, nombre de archivo) lanza IOException {
OutputStream OutputStream = mySocket.getOutputStream ();
StringBuffer sb = new StringBuffer ("http/1.1 200 ok/r/n");
sb.append ("servidor: java/1.1/r/n");
sb.append ("Content-type: Application/Octet-stream; Charset = UTF-8/R/N");
//sb.append("user-agent: mozilla/4.0 (compatible; msie6.0; windows nt 5.0)/r/n ");
SB.Append ("Contenido-Disposición: adjunto; FileName =" + FileName
+ "/r/n");
SB.Append ("Ecodificación de transferencia: Tritado/R/N");
sb.append ("Conexión: Keep-Alive/R/N/R/N");
outputStream.Write (SB.ToString (). GetBytes ());
outputStream.Flush ();
ZIPCOMPRESOR ZIPCOMPRESOR = NUEVO ZIPCOMPRESOR (nuevo MyOutputStream (
outputStream));
ZipCompressor.Compress (archivo);
System.out.println ("Zip End");
System.out.println ("escribir '0 // r // n // r // n'");
outputStream.Write ("0/r/n/r/n" .getBytes ()); // Econado de transferencia: Bandera de extremo de transmisión dijada
outputStream.Flush ();
outputStream.close ();
System.out.println ("Descargar parada");
intentar {
mysocket.close ();
} Catch (Throwable t) {
}
}
La copia del código es la siguiente:
paquete cn.liangjintang.webserver.zipfile;
import java.io.bufferedInputStream;
import java.io.file;
import java.io.fileInputStream;
import java.io.outputstream;
import java.lang.reflect.field;
import java.util.zip.crc32;
import java.util.zip.eckEdEdOutputStream;
import java.util.zip.zipentry;
import java.util.zip.zipoutputstream;
clase pública ZIPCOMPRESOR {
Buffer intent INT estático = 8192;
outputStream outputStream privado;
Public ZipCompressor (myOutputStream outputStream) {
this.outputStream = outputStream;
}
Public void compress (archivo de archivo) {
if (! file.exists ())
tirar nueva runtimeException (file.getabsolutePath () + "no existir!");
intentar {
CheckEdOutputStream cos = new CheckEdOutputStream (OutputStream,
nuevo crc32 ());
ZipOutputStream out = new ZipOutputStream (cos);
Cadena basada = "";
compress (archivo, out, basada);
out.close (); // debe cerrarse para que se escriba la información final de zip, de lo contrario, el archivo zip estará incompleto.
} capt (excepción e) {
tirar nueva runtimeException (e);
}
}
Private void compress (archivo de archivo, zipoutputstream out, string basado) {
// juzga si es un directorio o un archivo
if (file.isDirectory ()) {
System.out.println ("Compression:" + BaseIR + file.getName ());
this.comPressDirectory (archivo, out, basada);
} demás {
System.out.println ("Compression:" + BaseIR + file.getName ());
this.comPressFile (archivo, out, basada);
}
}
// comprimir un directorio
Private void compressDirectory (archivo dir, zipoutputstream out, string basado) {
if (! dir.exists ())
devolver;
Archivo [] archivos = dir.listFiles ();
for (int i = 0; i <files.length; i ++) {
/** Recursión*/
compress (archivos [i], out, basado + dir.getName () + "/");
}
}
// comprimir un archivo
privado void compressfile (archivo de archivo, zipoutputstream out, string basado) {
if (! file.exists ()) {
devolver;
}
intentar {
BufferedInputStream bis = new BufferedInputStream (
nuevo fileInputStream (archivo));
Zipentry entry = new ZipEntry (BaseIR + File.getName ());
out.putNextEntry (entrada);
int cuenta;
Datos de byte [] = new Byte [buffer];
while ((count = bis.read (data, 0, buffer))! = -1) {
out.write (datos, 0, recuento);
}
bis.close ();
} capt (excepción e) {
tirar nueva runtimeException (e);
}
}
}
La copia del código es la siguiente:
paquete cn.liangjintang.webserver.zipfile;
import java.io.filterOutputStream;
import java.io.ioException;
import java.io.outputstream;
MyOutputStream de clase pública extiende FilterOutputStream {
public myOutputStream (outputStream out) {
super (fuera);
}
Byte final [] OneBytes = "1/r/n" .getBytes ();
Byte final [] rnbytes = "/r/n" .getBytes ();
Public void Write (int b) lanza ioexception {
out.write (OneBytes); // bytes 1+CRLF
out.write (b); // Entidad de datos
out.write (rnbytes); // crlf
}
Public void Write (byte [] b) lanza ioexception {
out.write (integer.tohexstring (b.length) .getBytes ()); // bytes, hexadecimal
out.write (rnbytes); // crlf
out.write (b); // Entidad de datos
out.write (rnbytes); // crlf
}
Public void Write (byte [] b, int off, int len) lanza ioexception {
out.write (Integer.toHexString (Len - Off) .getBytes ()); // bytes, hexadecimal
out.write (rnbytes); // crlf
out.write (b, off, len); // Entidad de datos
out.write (rnbytes); // crlf
}
/**
* Reescribir este método, de lo contrario, el OutputStream se cerrará y otros datos <br/>
* (Por ejemplo, codificación de transferencia: bandera de extremo de transmisión fragmentada) ya no puede continuar escribiendo
*/
public void Close () lanza ioexception {
}
}