Mit dieser Methode können Sie Dateien sofort verpacken und während des Verpackens übertragen, ohne Cache zu verwenden, sodass Benutzer Null warten können!
Die Codekopie lautet wie folgt:
/**
*
* Mysocket Client Socket
* @Param -Datei Der Ordner oder die zu verpackte Datei
* @param Dateiname Der Dateinamen des verpackten Downloads
* @throws ioException
*/
private void Down (Dateidatei, String -Dateiname) löst IoException {aus
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: Anwendung/Oktett-Stream; charSet = utf-8/r/n");
//sb.append("user-Agent: Mozilla/4.0 (kompatibel; MSIE6.0; Windows NT 5.0)/r/n ");
SB.Append ("Inhaltsdisposition: Anhang; Dateiname =" + Dateiname
+ "/r/n");
SB.Append ("Transfer-Codierung: Chunked/r/n");
SB.Append ("Verbindung: Keep-Alive/R/N/R/N");
outputStream.write (sb.toString (). getBytes ());
outputStream.flush ();
Zip -Compressor -Zip -Compressor = neuer Zip -Compressor (neuer MyOutputStream (
Ausgangsstream));
ZipCompressor.compress (Datei);
System.out.println ("Zip End");
System.out.println ("schreiben '0 // r // n // r // n'");
outputStream.write ("0/r/n/r/n" .getBytes ()); // Transfer-Coding: Chunked Transmission End Flag
outputStream.flush ();
outputStream.close ();
System.out.println ("Download Stop");
versuchen {
mysocket.close ();
} catch (throwable t) {
}
}
Die Codekopie lautet wie folgt:
Paket cn.liangjintang.webserver.zipfile;
import Java.io.BufferedInputStream;
Import Java.io.file;
import Java.io.FileInputStream;
importieren java.io.outputstream;
Import Java.lang.reflect.field;
Import Java.util.zip.crc32;
import Java.util.zip.CheckedoutputStream;
import Java.util.zip.zipentry;
import Java.util.zip.zipoutputStream;
öffentliche Klasse Zip -Compressor {
statischer Final Int Puffer = 8192;
private outputStream outputStream;
öffentlicher Zip -Compressor (MyoutputStream OutputStream) {
this.outputStream = outputStream;
}
public void Compress (Dateidatei) {
if (! file.exists ())
Neue RunTimeException werfen (Datei.getabsolutepath () + "Nicht existieren!");
versuchen {
CheckedOutputStream cos = neu checkedOutputStream (Ausgangsstream,
neuer CRC32 ());
ZipoutputStream out = neu zipoutputStream (cos);
String -basiertesIR = "";
Kompress (Datei, out, basiert);
out.close (); // Es muss geschlossen werden, damit die Endinformationen von ZIP geschrieben werden. Andernfalls können die ZIP -Datei unvollständig sein.
} catch (Ausnahme e) {
neue runimeexception (e) werfen;
}
}
private void Compress (Dateidatei, ZipoutputStream, String -basiert) {
// Beurteilen Sie, ob es sich um ein Verzeichnis oder eine Datei handelt
if (file.isdirectory ()) {
System.out.println ("Komprimierung:" + -basiertes + file.getName ());
this.cressDirectory (Datei, out, basiert);
} anders {
System.out.println ("Komprimierung:" + -basiertes + file.getName ());
this.comPressfile (Datei, out, basiert);
}
}
// ein Verzeichnis komprimieren
private void compressDirectory (Datei Dir, ZipoutputStream, String -basiert) {
if (! Dir.Exists ())
zurückkehren;
Datei [] file = dir.listfiles ();
für (int i = 0; i <files.length; i ++) {
/** Rekursion*/
compress (Dateien [i], out, basierenir + dir.getName () + "/");
}
}
// eine Datei komprimieren
private void compressfile (Dateidatei, ZipoutputStream Out, String -basiert) {
if (! file.exists ()) {
zurückkehren;
}
versuchen {
BufferedInputStream Bis = neuer BufferedInputStream (
neuer FileInputStream (Datei));
ZIPEntry -Eintrag = neu Zipentry (basiertir + file.getName ());
out.putNextEntry (Eintrag);
int Count;
Byte -Daten [] = neues Byte [Puffer];
while ((count = Bis.read (Daten, 0, Puffer))! = -1) {
out.write (Daten, 0, count);
}
Bis.close ();
} catch (Ausnahme e) {
neue runimeexception (e) werfen;
}
}
}
Die Codekopie lautet wie folgt:
Paket cn.liangjintang.webserver.zipfile;
importieren java.io.filteroutputStream;
importieren java.io.ioException;
importieren java.io.outputstream;
öffentliche Klasse MyoutputStream erweitert FilteroutputStream {
public myoutputStream (outputStream) {
Super (out);
}
Final Byte [] oneBytes = "1/r/n" .GetByTes ();
Final Byte [] rnBytes = "/r/n" .GetByTes ();
public void write (int b) löst ioException {aus {
out.write (oneBytes); // bytes 1+crlf
out.write (b); // Datenentität
out.write (rnbytes); // crlf
}
public void write (byte [] b) löst ioException {aus
Out.Write (Integer.TohexString (b.Length) .getBytes ()); // bytes, hexadezimal
out.write (rnbytes); // crlf
out.write (b); // Datenentität
out.write (rnbytes); // crlf
}
public void write (byte [] b, int off, int len) löst ioException {aus
out.write (Integer.tohexString (len - off) .getBytes ()); // bytes, hexadezimal
out.write (rnbytes); // crlf
out.write (b, aus, len); // Datenentität
out.write (rnbytes); // crlf
}
/**
* Schreiben Sie diese Methode neu, ansonsten wird der Ausgangsstream geschlossen und andere Daten <br/>
* (Zum Beispiel kann Übertragungskodierung: Chunked Transmission End Flag) nicht mehr weiter schreiben
*/
public void close () wirft ioException {aus
}
}