En utilisant cette méthode, vous pouvez emballer des fichiers instantanément, les transférer lors de l'emballage, sans utiliser de cache, permettant aux utilisateurs d'attendre zéro!
La copie de code est la suivante:
/ **
*
* Prise client MySocket
* @param fichier le dossier ou le fichier à emballer
* @param nom de fichier le nom du fichier du téléchargement de l'emballage
* @throws ioexception
* /
private void down (fichier de fichier, nom de fichier de chaîne) lève ioException {
OutputStream OutputStream = mysocket.getOutputStream ();
StringBuffer sb = new StringBuffer ("http / 1.1 200 ok / r / n");
sb.append ("Server: 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 ("Disposition de contenu: pièce jointe; filename =" + nom de fichier
+ "/ r / n");
SB.APPEND ("Transfer-Encoding: Chunked / R / N");
SB.APPEND ("Connexion: Keep-Alive / R / N / R / N");
outputStream.Write (sb.toString (). GetBytes ());
outputStream.flush ();
Zipcompressor zipcompressor = new ZipCompressor (new myOutputStream (
outputStream));
zipcompressor.compress (fichier);
System.out.println ("zip end");
System.out.println ("Write '0 // r // n // r // n'");
outputStream.write ("0 / r / n / r / n" .getBytes ()); // transfert-codage: indicateur d'extrémité de transmission
outputStream.flush ();
outputStream.close ();
System.out.println ("Télécharger STOP");
essayer {
mysocket.close ();
} catch (t) {
}
}
La copie de code est la suivante:
Package CN.Liangjintang.webserver.zipfile;
Importer java.io.BufferedInputStream;
Importer java.io.file;
import java.io.fileInputStream;
import java.io.outputStream;
import java.lang.reflect.field;
import java.util.zip.crc32;
Importer java.util.zip.checkedoutputStream;
Importer java.util.zip.zipentry;
Importer java.util.zip.zipOutputStream;
classe publique ZipCompressor {
tampon int statique final = 8192;
Outpstream de sortie privée;
public zipcompressor (myOutputStream OutputStream) {
this.OutputStream = outputStream;
}
public void compress (fichier fichier) {
if (! file.exists ())
Jetez un nouveau RuntimeException (file.getAbsolutepath () + "pas exister!");
essayer {
CheckedOutputStream cos = new checkedoutputStream (outputStream,
Nouveau CRC32 ());
ZipOutputStream out = new ZipOutputStream (cos);
String-Basedir = "";
compress (fichier, out, basaseir);
out.close (); // il doit être fermé afin que les informations finales de ZIP soient écrites, sinon le fichier zip sera incomplet.
} catch (exception e) {
Jetez une nouvelle RuntimeException (E);
}
}
Private void Compress (fichier de fichier, zipOutputStream out, String Basedir) {
// juger s'il s'agit d'un répertoire ou d'un fichier
if (file.isdirectory ()) {
System.out.println ("Compression:" + basez-bason + file.getName ());
this.compressDirectory (fichier, out, basaseirIr);
} autre {
System.out.println ("Compression:" + basez-bason + file.getName ());
this.compressfile (fichier, out, basaseirIr);
}
}
// comprime un répertoire
private void CompressDirectory (fichier dir, zipOutStream out, string basasedir) {
if (! dir.exists ())
retour;
File [] files = dir.listFiles ();
for (int i = 0; i <files.length; i ++) {
/ ** Recursion * /
compress (fichiers [i], out, basaseir + dir.getName () + "/");
}
}
// comprime un fichier
private void compressfile (fichier file, zipOutputStream out, String Basedir) {
if (! file.exists ()) {
retour;
}
essayer {
BufferedInputStream bis = new BufferedInputStream (
new FileInputStream (fichier));
Zipentry Entry = new Zipentry (Basedir + file.getName ());
out.putNexTentry (entrée);
int count;
Données d'octets [] = nouveau octet [tampon];
while ((count = bis.read (data, 0, tampon))! = -1) {
out.write (données, 0, comte);
}
bis.close ();
} catch (exception e) {
Jetez une nouvelle RuntimeException (E);
}
}
}
La copie de code est la suivante:
Package CN.Liangjintang.webserver.zipfile;
import java.io.filterOutputStream;
Importer java.io.ioException;
import java.io.outputStream;
classe publique MyOutputStream étend FilterOutputStream {
public myOutputStream (outputStream out) {
super (out);
}
octet final [] onebytes = "1 / r / n" .getBytes ();
octet final [] rnbytes = "/ r / n" .getBytes ();
public void write (int b) lance ioexception {
out.write (one byte); // octets 1 + crlf
out.write (b); // entité de données
out.write (rnbytes); // crlf
}
public void write (octet [] b) lève ioException {
out.write (Integer.tohexstring (B.Length) .getBytes ()); // octets, hexadécimal
out.write (rnbytes); // crlf
out.write (b); // entité de données
out.write (rnbytes); // crlf
}
public void write (byte [] b, int off, int len) lève ioException {
out.write (Integer.tohexstring (len - off) .getBytes ()); // octets, hexadécimal
out.write (rnbytes); // crlf
out.write (b, off, len); // entité de données
out.write (rnbytes); // crlf
}
/ **
* Réécrivez cette méthode, sinon le sortie de sortie sera fermé, et d'autres données <br/>
* (Par exemple, le codage de transfert: indicateur de fin de transmission) ne peut plus continuer à écrire
* /
public void close () lève ioException {
}
}