Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
jar(1)				  Basic	Tools				jar(1)

NAME
       jar - Manipulates Java Archive (JAR) files.

SYNOPSIS
       Create JAR file

       jar c[efmMnv0] [entrypoint] [jarfile] [manifest]	[-C dir] file ... [-Joption ...] [@arg-file ...]

       Update JAR file

       jar u[efmMnv0] [entrypoint] [jarfile] [manifest]	[-C dir] file ... [-Joption ...] [@arg-file ...]

       Extract JAR file

       jar x[vf] [jarfile] file	... [-Joption ...] [@arg-file ...]

       List Contents of	JAR file

       jar t[vf] [jarfile] file	... [-Joption ...] [@arg-file ...]

       Add Index to JAR	file

       jar i jarfile [-Joption ...] [@arg-file ...]

DESCRIPTION
       The jar command is a general-purpose archiving and compression tool,
       based on	ZIP and	the ZLIB compression format. However, the jar command
       was designed mainly to package Java applets or applications into	a
       single archive. When the	components of an applet	or application (files,
       images and sounds) are combined into a single archive, they can be
       downloaded by a Java agent (such	as a browser) in a single HTTP
       transaction, rather than	requiring a new	connection for each piece.
       This dramatically improves download times. The jar command also
       compresses files, which further improves	download time. The jar command
       also allows individual entries in a file	to be signed by	the applet
       author so that their origin can be authenticated. A JAR file can	be
       used as a class path entry, whether or not it is	compressed.

       The syntax for the jar command resembles	the syntax for the tar
       command.	It has several operation modes,	defined	by one of the
       mandatory operation arguments. Other arguments are either options that
       modify the behavior of the operation, or	operands required to perform
       the operation.

OPERATION ARGUMENTS
       When using the jar command, you have to select an operation to be
       performed by specifying one of the following operation arguments. You
       can mix them up with other one-letter options on	the command line, but
       usually the operation argument is the first argument specified.

       c      Create a new JAR archive.

       i      Generate index information for a JAR archive.

       t      List the contents	of a JAR archive.

       u      Update a JAR archive.

       x      Extract files from a JAR archive.

OPTIONS
       Use the following options to customize how the JAR file is created,
       updated,	extracted, or viewed:

       e      Sets the class specified by the entrypoint operand to be the
	      entry point for a	standalone Java	application bundled into an
	      executable JAR file. The use of this option creates or overrides
	      the Main-Class attribute value in	the manifest file. The e
	      option can be used when creating (c) or updating (u) the JAR
	      file.

	      For example, the following command creates the Main.jar archive
	      with the Main.class file where the Main-Class attribute value in
	      the manifest is set to Main:

	      jar cfe Main.jar Main Main.class

	      The Java Runtime Environment (JRE) can directly call this
	      application by running the following command:

	      java -jar	Main.jar

	      If the entry point class name is in a package, then it could use
	      either the dot (.) or slash (/) as the delimiter.	For example,
	      if Main.class is in a package called mydir, then the entry point
	      can be specified in one of the following ways:

	      jar -cfe Main.jar	mydir/Main mydir/Main.class
	      jar -cfe Main.jar	mydir.Main mydir/Main.class

	      Note

	      Specifying both m	and e options together when a particular
	      manifest also contains the Main-Class attribute results in an
	      ambiguous	Main-Class specification. The ambiguity	leads to an
	      error and	the jar	command	creation or update operation is
	      terminated.

       f      Sets the file specified by the jarfile operand to	be the name of
	      the JAR file that	is created (c),	updated	(u), extracted (x)
	      from, or viewed (t). Omitting the	f option and the jarfile
	      operand instructs	the jar	command	to accept the JAR file name
	      from stdin (for x	and t) or send the JAR file to stdout (for c
	      and u).

       m      Includes names and values	of attributes from the file specified
	      by the manifest operand in the manifest file of the jar command
	      (located in the archive at META-INF/MANIFEST.MF).	The jar
	      command adds the attribute's name	and value to the JAR file
	      unless an	entry already exists with the same name, in which case
	      the jar command updates the value	of the attribute. The m	option
	      can be used when creating	(c) or updating	(u) the	JAR file.

	      You can add special-purpose name-value attribute pairs to	the
	      manifest that are	not contained in the default manifest file.
	      For example, you can add attributes that specify vendor
	      information, release information,	package	sealing, or to make
	      JAR-bundled applications executable. For examples	of using the m
	      option, see Packaging Programs at
	      http://docs.oracle.com/javase/tutorial/deployment/jar/index.html

       M      Does not create a	manifest file entry (for c and u), or delete a
	      manifest file entry when one exists (for u). The M option	can be
	      used when	creating (c) or	updating (u) the JAR file.

       n      When creating (c)	a JAR file, this option	normalizes the archive
	      so that the content is not affected by the packing and unpacking
	      operations of the	pack200(1) command. Without this
	      normalization, the signature of a	signed JAR can become invalid.

       v      Generates	verbose	output to standard output. See Examples.

       0      (Zero) Creates (c) or updates (u)	the JAR	file without using ZIP
	      compression.

       -C dir
	      When creating (c)	or updating (u)	a JAR file, this option
	      temporarily changes the directory	while processing files
	      specified	by the file operands. Its operation is intended	to be
	      similar to the -C	option of the UNIX tar utility.For example,
	      the following command changes to the classes directory and adds
	      the Bar.class file from that directory to	my.jar:

	      jar uf my.jar -C classes Bar.class

	      The following command changes to the classes directory and adds
	      to my.jar	all files within the classes directory (without
	      creating a classes directory in the JAR file), then changes back
	      to the original directory	before changing	to the bin directory
	      to add Xyz.class to my.jar.

	      jar uf my.jar -C classes . -C bin	Xyz.class

	      If classes contained files bar1 and bar2,	then the JAR file will
	      contain the following after running the previous command:

	      %	jar tf my.jar
	      META-INF/
	      META-INF/MANIFEST.MF
	      bar1
	      bar2
	      Xyz.class

       -Joption
	      Sets the specified JVM option to be used when the	JRE runs the
	      JAR file.	JVM options are	described on the reference page	for
	      the java(1) command. For example,	-J-Xms48m sets the startup
	      memory to	48 MB.

OPERANDS
       The following operands are recognized by	the jar	command.

       file   When creating (c)	or updating (u)	a JAR file, the	file operand
	      defines the path and name	of the file or directory that should
	      be added to the archive. When extracting (x) or listing the
	      contents (t) of a	JAR file, the file operand defines the path
	      and name of the file to be extrated or listed. At	least one
	      valid file or directory must be specified. Separate multiple
	      file operands with spaces. If the	entrypoint, jarfile, or
	      manifest operands	are used, the file operands must be specified
	      after them.

       entrypoint
	      When creating (c)	or updating (u)	a JAR file, the	entrypoint
	      operand defines the name of the class that should	be the entry
	      point for	a standalone Java application bundled into an
	      executable JAR file. The entrypoint operand must be specified if
	      the e option is present.

       jarfile
	      Defines the name of the file to be created (c), updated (u),
	      extracted	(x), or	viewed (t). The	jarfile	operand	must be
	      specified	if the f option	is present. Omitting the f option and
	      the jarfile operand instructs the	jar command to accept the JAR
	      file name	from stdin (for	x and t) or send the JAR file to
	      stdout (for c and	u).

	      When indexing (i)	a JAR file, specify the	jarfile	operand
	      without the f option.

       manifest
	      When creating (c)	or updating (u)	a JAR file, the	manifest
	      operand defines the preexisting manifest files with names	and
	      values of	attributes to be included in MANIFEST.MF in the	JAR
	      file. The	manifest operand must be specified if the f option is
	      present.

       @arg-file
	      To shorten or simplify the jar command, you can specify
	      arguments	in a separate text file	and pass it to the jar command
	      with the at sign (@) as a	prefix.	When the jar command
	      encounters an argument beginning with the	at sign, it expands
	      the contents of that file	into the argument list.

	      An argument file can include options and arguments of the	jar
	      command (except the -J options, because they are passed to the
	      launcher,	which does not support argument	files).	The arguments
	      within a file can	be separated by	spaces or newline characters.
	      File names within	an argument file are relative to the current
	      directory	from which you run the jar command, not	relative to
	      the location of the argument file. Wild cards, such as the
	      asterisk (*), that might otherwise be expanded by	the operating
	      system shell, are	not expanded.

	      The following example, shows how to create a classes.list	file
	      with names of files from the current directory output by the
	      find command:

	      find . -name '*.class' -print > classes.list

	      You can then execute the jar command and pass the	classes.list
	      file to it using the @arg-file syntax:

	      jar cf my.jar @classes.list

	      An argument file can be specified	with a path, but any file
	      names inside the argument	file that have relative	paths are
	      relative to the current working directory	of the jar command,
	      not to the path passed in, for example:

	      jar @dir/classes.list

NOTES
       The e, f, and m options must appear in the same order on	the command
       line as the entrypoint, jarfile,	and manifest operands, for example:

       jar cmef	myManifestFile MyMainClass myFile.jar *.class

EXAMPLES
       Example 1 Adding	All Files From the Current Directory With Verbose
       Output

       % ls
       1.au	     Animator.class    monkey.jpg
       2.au	     Wave.class	       spacemusic.au
       3.au	     at_work.gif
       % jar cvf bundle.jar *
       added manifest
       adding: 1.au(in = 2324) (out= 67)(deflated 97%)
       adding: 2.au(in = 6970) (out= 90)(deflated 98%)
       adding: 3.au(in = 11616)	(out= 108)(deflated 99%)
       adding: Animator.class(in = 2266) (out= 66)(deflated 97%)
       adding: Wave.class(in = 3778) (out= 81)(deflated	97%)
       adding: at_work.gif(in =	6621) (out= 89)(deflated 98%)
       adding: monkey.jpg(in = 7667) (out= 91)(deflated	98%)
       adding: spacemusic.au(in	= 3079)	(out= 73)(deflated 97%)

       Example 2 Adding	Files From Subdirectories

       % ls -F
       audio/ classes/ images/
       % jar cvf bundle.jar audio classes images
       added manifest
       adding: audio/(in = 0) (out= 0)(stored 0%)
       adding: audio/1.au(in = 2324) (out= 67)(deflated	97%)
       adding: audio/2.au(in = 6970) (out= 90)(deflated	98%)
       adding: audio/3.au(in = 11616) (out= 108)(deflated 99%)
       adding: audio/spacemusic.au(in =	3079) (out= 73)(deflated 97%)
       adding: classes/(in = 0)	(out= 0)(stored	0%)
       adding: classes/Animator.class(in = 2266) (out= 66)(deflated 97%)
       adding: classes/Wave.class(in = 3778) (out= 81)(deflated	97%)
       adding: images/(in = 0) (out= 0)(stored 0%)
       adding: images/monkey.jpg(in = 7667) (out= 91)(deflated 98%)
       adding: images/at_work.gif(in = 6621) (out= 89)(deflated	98%)
       % ls -F
       audio/ bundle.jar classes/ images/

       Example 3 Listing the Contents of JAR

       % jar tf	bundle.jar

       META-INF/
       META-INF/MANIFEST.MF
       audio/1.au
       audio/2.au
       audio/3.au
       audio/spacemusic.au
       classes/Animator.class
       classes/Wave.class
       images/monkey.jpg
       images/at_work.gif

       Example 4 Adding	an Index

       Use the i option	when you split the interdependent classes for a	stock
       trade application into three JAR	files: main.jar, buy.jar, and
       sell.jar. If you	specify	the Class-Path attribute in the	main.jar
       manifest, then you can use the i	option to speed	up the class loading
       time for	your application:

       Class-Path: buy.jar sell.jar
       jar i main.jar

       An INDEX.LIST file is inserted to the META-INF directory. This enables
       the application class loader to download	the specified JAR files	when
       it is searching for classes or resources.

       The application class loader uses the information stored	in this	file
       for efficient class loading. To copy directories, first compress	files
       in dir1 to stdout, then pipeline	and extract from stdin to dir2
       (omitting the -f	option from both jar commands):

       (cd dir1; jar c .) | (cd	dir2; jar x)

SEE ALSO
       o pack200(1).

       o The JAR section of The	Java Tutorials at
	 http://docs.oracle.com/javase/tutorial/deployment/jar/index.html

JDK 8			       21 November 2013				jar(1)

NAME | SYNOPSIS | DESCRIPTION | OPERATION ARGUMENTS | OPTIONS | OPERANDS | NOTES | EXAMPLES | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=jar&sektion=1&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help