So erstellen Sie .zip oder .tar programmatisch in Java mit Apache Commons Archivers and Compressors

Veröffentlicht: 2016-03-08

Wie man .zip und .tar in Java programmatisch erstellt

Apache Foundation enthält standardmäßig viele, viele Dienstprogramme, die wir verwenden können. In den meisten Fällen sind wir uns des Dienstprogramms, das für die Verwendung in unserer Produktionsumgebung vorhanden ist, nicht bewusst.

In diesem Tutorial gehen wir auf eines der Dienstprogramme ein, mit denen wir jede Datei oder jedes Verzeichnis programmgesteuert in Java komprimieren können. Mit anderen Worten, ein einfaches Archivdienstprogramm.

Warum brauchen wir dieses Dienstprogramm?

Vor einiger Zeit habe ich einen Artikel darüber geschrieben, wie man Dateien mit der Spring MVC-Architektur hochlädt. Wenn Sie eine sehr große Datei haben und Dateien anderer Benutzer in einigen Dateisystemen wie NetApp oder Filer usw. hosten, möchten Sie die Dateien möglicherweise vor dem Hochladen komprimieren. Sie können den folgenden Code in Ihre Anwendung einfügen, um denselben Zweck zu erreichen.

Sehen wir uns zuerst ein Ergebnis an, um es besser zu verstehen:

Vor:

Crunchify Tar Utility - Datei und Verzeichnis .zip oder .tar

Nach dem:

crunchify*.zip-Datei, die vom Java-Programm erstellt wurde

Lass uns anfangen:

  • Erstellen Sie die Klasse CrunchifyCompressArchivesUtility.java
  • Fügen Sie Ihrem Projekt die folgende Maven-Abhängigkeit hinzu.
  • Wenn Sie kein Maven-Projekt haben, befolgen Sie diese Schritte.

commons-compress maven pom.xml dependency
1
2
3
4
5
< dependency >
< groupId > org . apache . commons < / groupId >
< artifactId > commons - compress < / artifactId >
< version > 1.9 < / version >
< / dependency >

  • Wir werden das Apache Commons compress archivers verwenden
  • Die Klasse TarArchiveEntry repräsentiert einen Eintrag in einem Tar-Archiv. Es besteht aus dem Header des Eintrags sowie der Datei des Eintrags. Einträge können auf eine von drei Arten instanziiert werden, je nachdem, wie sie verwendet werden sollen.
  • Die Klasse TarArchiveOutputStream schreibt ein UNIX-Tar-Archiv als OutputStream.
  • Wir werden zunächst nur eine Datei archivieren
  • Auch im selben Programm werden wir ein Verzeichnis archivieren
  • Wir werden Datei und Verzeichnis in eine .zip -Datei konvertieren. Wenn Sie .tar möchten, ändern Sie einfach den Code unten.
  • Bitte ändern Sie den Pfad im folgenden Code

CrunchifyCompressArchivesUtility.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
package com . crunchify . tutorials ;
 
import java . io . BufferedInputStream ;
import java . io . File ;
import java . io . FileInputStream ;
import java . io . FileOutputStream ;
 
import org . apache . commons . compress . archivers . tar . TarArchiveEntry ;
import org . apache . commons . compress . archivers . tar . TarArchiveOutputStream ;
 
/**
* @author Crunchify.com
*
*/
 
public class CrunchifyCompressArchivesUtility {
 
private static final String CRUNCHIFY_BASEDIR = "" ;
 
// Default output path
private static final String CRUNCHIFY_PATH = "/Users/<username>/Desktop/" ;
 
// .zip or .tar as per need
private static final String FILE_EXTENSION = ".zip" ;
 
public static void main ( String [ ] args ) {
try {
 
// Archive File
crunchfyArchive ( "/Users/appshah/Desktop/crunchifyTarFile.txt" ) ;
log ( "Archive a file task completed...\n" ) ;
 
// Archive Directory
crunchfyArchive ( "/Users/appshah/Desktop/crunchifyTarDirectory" ) ;
log ( "Archive a Directory task completed..." ) ;
} catch ( Exception e ) {
log ( e . getStackTrace ( ) . toString ( ) ) ;
}
 
}
 
public static void crunchfyArchive ( String srcPath ) throws Exception {
File crunchifySourceFile = new File ( srcPath ) ;
 
// Returns the name of the file or directory denoted by this abstract pathname
String crunchifyFileName = crunchifySourceFile . getName ( ) ;
 
// Returns the pathname string of this abstract pathname's parent
String crunchifyBaseFileNamePath = crunchifySourceFile . getParent ( ) ;
 
String destPath = crunchifyBaseFileNamePath + File . separator + crunchifyFileName + FILE_EXTENSION ;
 
log ( "Archived Location: " + destPath ) ;
TarArchiveOutputStream outputStream = new TarArchiveOutputStream (
new FileOutputStream ( new File ( destPath ) ) ) ;
 
crunchfyArchive ( crunchifySourceFile , outputStream , CRUNCHIFY_BASEDIR ) ;
 
// Flushes this output stream and forces any buffered output bytes to be written out
outputStream . flush ( ) ;
 
// Closes the underlying OutputStream
outputStream . close ( ) ;
}
 
private static void crunchfyArchive ( File crunchifySourceFile ,
TarArchiveOutputStream outputStream , String crunchifyBasePath ) throws Exception {
if ( crunchifySourceFile . isDirectory ( ) ) {
 
// Archive Directory
archiveCrunchifyDirectory ( crunchifySourceFile , outputStream , crunchifyBasePath ) ;
} else {
 
// Archive File
archiveCrunchifyFile ( crunchifySourceFile , outputStream , crunchifyBasePath ) ;
}
}
 
private static void archiveCrunchifyDirectory ( File crunchifyDirectory ,
TarArchiveOutputStream outputStream , String crunchifyBasePath ) throws Exception {
 
// Returns an array of abstract pathnames denoting the files in the directory denoted by this abstract pathname
File [ ] crunchifyFiles = crunchifyDirectory . listFiles ( ) ;
 
if ( crunchifyFiles ! = null ) {
if ( crunchifyFiles . length < 1 ) {
 
// Construct an entry with only a name. This allows the programmer to construct the entry's header "by hand". File
// is set to null
TarArchiveEntry entry = new TarArchiveEntry (
crunchifyBasePath + crunchifyDirectory . getName ( ) + CRUNCHIFY_PATH ) ;
 
// Put an entry on the output stream
outputStream . putArchiveEntry ( entry ) ;
 
// Close an entry. This method MUST be called for all file entries that contain data
outputStream . closeArchiveEntry ( ) ;
}
 
// Repeat for all files
for ( File crunchifyFile : crunchifyFiles ) {
 
crunchfyArchive ( crunchifyFile , outputStream ,
crunchifyBasePath + crunchifyDirectory . getName ( ) + CRUNCHIFY_PATH ) ;
 
}
}
}
 
private static void archiveCrunchifyFile ( File crunchifyFile ,
TarArchiveOutputStream outputStream , String crunchifyDirectory ) throws Exception {
 
TarArchiveEntry crunchifyEntry = new TarArchiveEntry (
crunchifyDirectory + crunchifyFile . getName ( ) ) ;
 
// Set this entry's file size
crunchifyEntry . setSize ( crunchifyFile . length ( ) ) ;
 
outputStream . putArchiveEntry ( crunchifyEntry ) ;
 
BufferedInputStream inputStream = new BufferedInputStream (
new FileInputStream ( crunchifyFile ) ) ;
int counter ;
 
// 512: buffer size
byte byteData [ ] = new byte [ 512 ] ;
while ( ( counter = inputStream . read ( byteData , 0 , 512 ) ) ! = - 1 ) {
outputStream . write ( byteData , 0 , counter ) ;
}
 
inputStream . close ( ) ;
outputStream . closeArchiveEntry ( ) ;
}
 
// Crunchify's favorite log utility
private static void log ( String string ) {
System . out . println ( string ) ;
 
}
 
}

Ausgabe

Result
1
2
3
4
5
Archived Location: /Users/<username>/Desktop/crunchifyTarFile.txt.zip
Archive a file task completed...
 
Archived Location: /Users/<username>/Desktop/crunchifyTarDirectory.zip
Archive a Directory task completed...