Some Important Links

• Subversion:
• Web Site: http://subclipse.tigris.org/
• Eclipse Update: http://subclipse.tigris.org/servlets/ProjectProcess?pageID=p4wYuA
• Maven:
• M2E: http://m2eclipse.sonatype.org/sites/
• VideoLan:
• http://www.videolan.org/vlc/features.html
• 7 Zip:
• http://www.7-zip.org/download.html

Apache JMeter

Apache J Meter

# - Remember to set JAVA_HOME to JDK 5+
Example:
Server 1:
JAVA_HOME=/app/weblogic/jdk1.6.0_33/bin

WEBLOGIC_HOME=/app/home/mradmin/Oracle/Middleware
APACHE_HOME=/app/cemp/apache-jmeter-2.7
PATH=/app/weblogic/jdk1.6.0_33/bin:/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/app/home/mradmin/bin:/app/cemp/apache-jmeter-2.7/bin/ApacheJMeter.jar:
export PATH
Server 2: [Same on Server 2]

# - [cemp@cempda01 bin]$ jmeter -n -r -t Usage\ Cache\ Users.jmx -LDEBUG -l results.jtl
Example #:

[cemp@cempda01 bin]$ jmeter -n -r -t UsageCacheUsers.jmx -LDEBUG -l results.jtl
Created the tree successfully using UsageCacheUsers.jmx

Configuring remote engine for cmpcol-dt-4d.ula.com.net
Using remote object: UnicastRef [liveRef: [endpoint:[10.255.156.129:49889](remote),objID:[71770134:138a12bc3d9:-7fff, 5263036063349195177]]]
Configuring remote engine for cempda01.cab.com.com
Using remote object: UnicastRef [liveRef: [endpoint:[147.191.113.124:34820](remote),objID:[584b8767:138a1409048:-7fff, -1613329581385448862]]]
Starting remote engines
Starting the test @ Fri Jul 20 05:29:06 UTC 2012 (1342762146778)
Remote engines have been started
Waiting for possible shutdown message on port 4445
Generate Summary Results + 916 in 31.3s = 29.3/s Avg: 34 Min: 21 Max: 176 Err: 0 (0.00%)
Generate Summary Results + 2631 in 89.0s = 29.6/s Avg: 35 Min: 20 Max: 134 Err: 0 (0.00%)
Generate Summary Results = 3547 in 120.3s = 29.5/s Avg: 35 Min: 20 Max: 176 Err: 0 (0.00%)
Tidying up remote @ Fri Jul 20 05:31:29 UTC 2012 (1342762289011)
... end of run
[cemp@cempda01 bin]$
# - Important Commands:
1. [cemp@cempda01 bin]$ netstat -tulpn // Check port - process id.
2. Microsoft Windows:  start rmiregistry 30031 // remember to JAVA_HOME before.
3. Solaris OS or Linux:  rmiregistry 30031 & // remember to set JAVA_HOME before.
By default, the registry runs on port 1099. To start the registry on a different port, specify the port number on the command line. Do not forget to unset your CLASSPATH environment variable.
To check that the RMI registry has started correctly, you can check that it is listening on its standard port (1099 unless you've specified otherwise) with a tool such as TCP View.






 
 
 

Mozilla Unresponsive Script

Any Solution ?

Warning: Unresponsible Script

A script on this page may be busy , or it may have stopped responding. You can stop the script now, or you can continue to see if the script will complete.
Script: http://s.ytimg.com/yt/jsbin/www-core-vf19FZ5Nr.js:219

CVS Quick Reference

CVS Options
Use the following syntax to issue CVS Commands:
$ cvs [cvs-option] command [cmd-options] [args]

Replace cvs-options with one  or more of the following:
1. -a : Authenticate the data stream
2. --allow-root=directory : Set the repository root directory (used in server modes)
3. -d repository-path : Specify the repository path for the current command
4. -e editor : Use the specified editor in commit or import commands.
5. -f : Do not use the ~/.cvsrc file
6. -H or --help : Display help for CVS
7. --help-commands : Display a list of CVS Commands.
8. --help-options : Display a list of CVS Options.
9. --help-synonyms : Display a list of synonyms for CVS commands.
10. --H command or --help command : Display the options and help for the specified command.
11. -l : Do not log the current command to the history file.
12. -n : do not write to the repository or sandbox.
13. -q : Run in quiet mode.
14. -Q : Run in very quiet mode.
15. -r : Set files checked out to the sandbox read-only.
16. -s : variable=value : Set a user variable for use with one of the scripting files in CVSROOT
17. -t: Display messages that trance the execution of the command.
18. -v or --version : Display CVS version and copyright information.
19. -w : Set files checked out to the sandbox readable and writable.
20. -x : Encrypt all data that travels across the network.
21. -z # : Compress all network traffic using the specified gzip compression level.

Repository Access:
Repository path information is as follows:
[:method] [[[user][:password]@]hostname[:[port]]]/path 

Access method can be any of the following:
1. ext: Connection through external rsh or rsh-like program.
2. fork: Client / server mode on local computer.
3. gserver : Connection through the GSS-API and Kerberos 5
4. local : Local computer, no client / server mode.
5. pserver : Connection through password server.
6. kserver: Connection through kerberos 4.
7. server: Connection through internal rsh server key environment variables relating to repository access are
     CVS_RSH: Specifies rsh-like executable.
     CVSROOT: Specifies repository path.

Common CVS Tasks:
The following lists show the syntax to use in performing common CVS tasks. Remember that for any CVS command you can specify the repository path using the -d option. For example:
$ cvs -d repository_path checkout project
For brevity, the -d option is not shown in any of the example commands. However, it can be added to any of the commands.

Sandbox Commands:
Create a new sandbox: $ cvs checkout project
Remove a sandbox: $ cvs release directory
Check out files as of a specific tag name or revision: $ cvs checkout -r [tagname | revision] project
Check out files as of a specific date or time:  $ cvs checkout -D [date|time] project

Synchronization Commands:
Upload changes to the repository: $ cvs commit [filenames]
Force upload of unchanged files: $ cvs commit -f [filenames]
Download changes from the repository: $ cvs update [filenames]
Download changes and download new directories: $ cvs update -d [filenames]
Download changes. but not empty directories : $ cvs update -P [filenames]
Download changes, clear sticky revision, date, keyword mode or branch: $ cvs update -A [filenames]
Convert an existing sandbox to a specific tag name or revision: $ cvs update -r [tagname | revision] project
Convert an existing sandbox to a specific date or time: $ cvs update -D [date|time] project

File Commands:
Add new files or directories to the repository: $ cvs add [filenames]
Add new binary files to the repository: $ cvs add -kb [filenames]
Remove files or directories from the repository: $ cvs remove [filenames]

Branch Commands:
Create a branch from within a sandbox: $ cvs tag -b branchname [filenames]
Create a branch from anywhere using a tag name or revision: $ cvs rtag -r [tagname|revision] -b branchname project
Create a branch from anywhere using a date or time: $ cvs rtag -D [date|time] branchname project
Checkout a branch sandbox: $ cvs checkout -r branchname project
Convert an existing sandbox to a branch sandbox: $ cvs update -r branchname [filenames]

Tag Commands:
Tag files from within a sandbox: $ cvs tag tagname [filenames]
Tag files from anywhere using a tag name or revision: $ cvs rtag -r [existing_tagname | revision] new_tagname project
Tag files from anywhere using a date or time: $ cvs rtag -D [date|time] tagname project
Move a tag from within a sandbox: $ cvs tag -F tagname [filenames]
Move a tag from anywhere using a tag name or revision: $ cvs rtag -r [tagname_at_location|revision] -F tagname_to_more project
Move a tag form anywhere using a date or time: $ cvs rtag -D [date|time] -F tagname project
Delete a tag from within a sandbox: $ cvs tag -d tagname [filenames]
Delete a tag from anywhere: $cvs rtag -d tagname project

The -r [tagname|revision] option accepts a tag name or revision, but cannot have both tag name and revision. The -D [date|time] option accepts a date, a time, or both date and time.

CVSROOT: :ssh:adixit3034c@cmputl-po-3p:/opt/cm/cmsys/cvs/root
Server: cmputl-po-3p
Repository Folder: /opt/cm/cmsys/cvs/root

Username: adixit3034c

[Working]$ cvs -d adixit3034c@cmputl-po-3p:/opt/cm/cmsys/cvs/root checkout -P -r CFX_BR_EEPBill_DDPMediation_2_0_0_5 CFX_BR_EEPBill_DDPMediation

$ cd /data/Release_elements/current/US242513
$ tar -czvf CFX_BR_EEPBill_DDPMediation_2_0_0_5.tar.gz CFX_BR_EEPBill_DDPMediation_2_0_0_5

$ chmod 755 CFX_BR_EEPBill_DDPMediation_2_0_0_5 -R
$ cd /data/Release_elements/current/US242513/CFX_BR_EEPBill_DDPMediation_2_0_0_5/_EEPBill_DDPMediation/app

$ mvn clean install -Dmaven.test.skip=true

Location: http://cmputl-po-4p/cm_workareas/current/

Maven Important Command

Command 1. The install:install goal
In most cases, install:install goal doesn't need any configuration, it needs the project's POM and the artifact file to be installed during the install phase of the default build lifecycle. mvn install :: install:install-file goal
The install:install-file goal is used primarily for installing artifacts to the local repository which were not built by Maven. The project's development team may or may not provide a POM for the artifact. Here's a list of some of the available parameters for the install-file goal:

$mvn install:install-file -Dfile=your-artifact-1.0.jar [-DpomFile=your-pom.xml] [-Dsources=src.jar] [-Djavadoc=apidocs.jar] [-DgroupId=org.some.group] [-DartifactId=your-artifact] [-Dversion=1.0] [-Dpackaging=jar] [-Dclassifier=sources] [-DgeneratePom=true] [-DcreateChecksum=true]

• The groupId, artifactId, version and packaging of the file to install. These can be taken from the specified pomFile, and overridden or specified using the command line. When the pomFile contains a parent section, the parent's groupId can be considered if the groupId is not specified further for the current project or on the command line.
• The optional classifier parameter can be used to install secondary artifacts for a project, like a javadoc or sources JAR. If a classifier is not given, Maven assumes the file is the main artifact for the project.

Command 2: The deploy:deploy Mojo
In most cases, this mojo is invoked when you call the deploy phase of the default build lifecycle.
To enable this mojo to function, you must include a valid section POM, which at the minimum provides a defining the remote repository location for your artifact. To separate snapshot artifacts from release artifacts, you can also specify a location. Finally, to deploy a project website, you must specify a section here as well. It's also important to note that this section can be inherited, allowing you to specify the deployment location one time for a set of related projects.
If your repository is secured, you may also want to configure your settings.xml file to define corresponding entries which provides authentication information. Server entries are matched to the different parts of the distributionManagement using their elements. For example, your project may have a distributionManagement section similar to the following:
[...]
 
   
      internal.repo
      MyCo Internal Repository
      Host to Company Repository
   
 
[...]
In this case, you can specify a server definition in your settings.xml to provide authentication information for both of these repositories at once. Your server section might look like this:
[...]
   
      internal.repo
      maven
      foobar
   
[...]
Please see the article about Password Encryption for instructions on how to avoid clear text passwords in the settings.xml.
Once you've configured your repository deployment information correctly deploying your project's artifact will only require invocation of the deploy phase of the build:
mvn deploy
The deploy:deploy-file Mojo
The deploy:deploy-file mojo is used primarily for deploying artifacts to which were not built by Maven. The project's development team may or may not provide a POM for the artifact, and in some cases you may want to deploy the artifact to an internal remote repository. The deploy-file mojo provides functionality covering all of these use cases, and offers a wide range of configurability for generating a POM on-the-fly. Additionally, you can specify what layout your repository uses. The full usage statement of the deploy-file mojo can be described as:
mvn deploy:deploy-file -Durl=file://C:\m2-repo -DrepositoryId=some.id -Dfile=your-artifact-1.0.jar [-DpomFile=your-pom.xml] [-DgroupId=org.some.group] [-DartifactId=your-artifact] [-Dversion=1.0] [-Dpackaging=jar] [-Dclassifier=test] [-DgeneratePom=true] [-DgeneratePom.description="My Project Description"] [-DrepositoryLayout=legacy] [-DuniqueVersion=false]
If the following required information is not specified in some way, the goal will fail:
•The artifact file to deploy
•The group, artifact, version and packaging of the file to deploy. These can be taken from the specified pomFile, and overriden or specified using the command line. When the pomFile contains a parent section, the parent's groupId can be considered if the groupId is not specified further for the current project or on the command line.
•The repository information: the url to deploy to and the repositoryId mapping to a server section in the settings.xml file. If you don't specify a repositoryId, Maven will try to extract authentication information using the id 'remote-repository'.


More about maven:
1. Plugins
2. Maven & Source Code

J B O S S

EAP: Enterprise Application Platform

JBoss Developer Studio:
Configure Maven in JBoss Developer Studio:
Click Window→Preferences, expand JBoss T ools and select JBoss Maven Integration.

Add a repository [jboss-earlyaccess-repository] > 
Profile Id: jboss-ga-repository
Repository: ID: jboss-ga-repository; Name:jboss-ga-repository; URL: http://maven.repository.redhat.com/techpreview/all

Add early access repository[jboss-earlyaccess-repository]>
Profile Id:jboss-earlyaccess-repository
Repository: ID:jboss-earlyaccess-repository ; Name:jboss-earlyaccess-repository ; URL:http://maven.repository.redhat.com/earlyaccess/all/


First Time when we start JBOSS EAP Server, it will give following message:

- - - - - - - - - - - - - - - - - - - - - 

Welcome to EAP 6
The Enterprise Application Platform 6 is running.
However you have not yet added any users to be able to access the admin console.
To add a new user execute the add-user.sh script within the bin folder of your EAP 6 installation and enter the requested information.
By default the realm name used by EAP is "ManagementRealm" this is already selected by default.
After you have added the user follow this link to Try Again.

- - - - - - - - - - - - - - - - - - - - - 

Packaging Programs in JAR Files

The Java™ Archive (JAR) file format enables you to bundle multiple files into a single archive file. Typically a JAR file contains the class files and auxiliary resources associated with applets and applications.

The JAR file format provides many benefits:

• Security: You can digitally sign the contents of a JAR file. Users who recognize your signature can then optionally grant your software security privileges it wouldn't otherwise have.
• Decreased download time: If your applet is bundled in a JAR file, the applet's class files and associated resources can be downloaded to a browser in a single HTTP transaction without the need for opening a new connection for each file.
• Compression: The JAR format allows you to compress your files for efficient storage.
• Packaging for extensions: The extensions framework provides a means by which you can add functionality to the Java core platform, and the JAR file format defines the packaging for extensions. By using the JAR file format, you can turn your software into extensions as well.
• Package Sealing: Packages stored in JAR files can be optionally sealed so that the package can enforce version consistency. Sealing a package within a JAR file means that all classes defined in that package must be found in the same JAR file.
• Package Versioning: A JAR file can hold data about the files it contains, such as vendor and version information.
• Portability: The mechanism for handling JAR files is a standard part of the Java platform's core API.

Using JAR File

JAR files are packaged with the ZIP file format, so you can use them for tasks such as lossless data compression, archiving, decompression, and archive unpacking. These tasks are among the most common uses of JAR files, and you can realize many JAR file benefits using only these basic features.
Even if you want to take advantage of advanced functionality provided by the JAR file format such as electronic signing, you'll first need to become familiar with the fundamental operations.
To perform basic tasks with JAR files, you use the Java Archive Tool provided as part of the Java Development Kit (JDK). Because the Java Archive tool is invoked by using the jar command, this tutorial refers to it as 'the Jar tool'.
As a synopsis and preview of some of the topics to be covered in this section, the following table summarizes common JAR file operations:

Common JAR file operations

Operation	Command
To create a JAR file	jar cf jar-file input-file(s)
To view the contents of a JAR file	jar tf jar-file
To extract the contents of a JAR file	jar xf jar-file
To extract specific files from a JAR file	jar xf jar-file archived-file(s)
To run an application packaged as a JAR file (requires the Main-class manifest header)	java -jar app.jar
To invoke an applet packaged as a JAR file	<applet code=AppletClassName.class archive="JarFileName.jar" width=width height=height> </applet>

This section shows you how to perform the most common JAR-file operations, with examples for each of the basic features:

1. Creating a JAR File: This section shows you how to use the Jar tool to package files and directories into a JAR file.
2. Viewing the Contents of a JAR File: You can display a JAR file's table of contents to see what it contains without actually unpacking the JAR file.
3. Extracting the Contents of a JAR File: You can use the Jar tool to unpack a JAR file. When extracting files, the Jar tool makes copies of the desired files and writes them to the current directory, reproducing the directory structure that the files have in the archive.
4. Updating a JAR File: This section shows you how to update the contents of an existing JAR file by modifying its manifest or by adding files.
5. Running JAR-Packaged Software: This section shows you how to invoke and run applets and applications that are packaged in JAR files.

Working With Manifest File

JAR files support a wide range of functionality, including electronic signing, version control, package sealing, and others. What gives a JAR file this versatility? The answer is the JAR file's manifest. The manifest is a special file that can contain information about the files packaged in a JAR file. By tailoring this "meta" information that the manifest contains, you enable the JAR file to serve a variety of purposes.

This lesson will explain the contents of the manifest file and show you how to work with it, with examples for the basic features:

• Understanding the Default Manifest: When you create a JAR file, a default manifest is created automatically. This section describes the default manifest.
• Modifying a Manifest File: This section shows you the basic method of modifying a manifest file. The later sections demonstrate specific modifications you may want to make.
• Setting an Application's Entry Point: This section describes how to use the Main-Class header in the manifest file to set an application's entry point.
• Adding Classes to the JAR File's Classpath: This section describes how to use the Class-Path header in the manifest file to add classes in other JAR files to the classpath when running an applet or application.
• Setting Package Version Information: This section describes how to use the package version headers in the manifest file.
• Sealing Packages within a JAR File: This section describes how to seal packages within a JAR file by modifying the manifest file.
• Enhancing Security with Manifest Attributes: This section describes how to use manifest attributes to increase the security of an applet or Java Web Start application.

Signing and Verifying JAR File

You can optionally sign a JAR file with your electronic "signature." Users who verify your signature can grant your JAR-bundled software security privileges that it wouldn't ordinarily have. Conversely, you can verify the signatures of signed JAR files that you want to use.

This lesson shows you how to use the tools provided in the JDK to sign and verify JAR files:

Understanding Signing and Verification: If you're not familiar with the concepts of signing and verification, this section will help to bring you up to speed. It contains definitions of the relevant terms, explanations of some of the benefits provided by signing, and an outline of the signing mechanism used by the Java platform as it relates to JAR files.

Signing JAR Files: In this section, you'll learn how to use the JDK™ tools to digitally sign your JAR files.

Verifying Signed JAR Files:This section shows you how to use the JDK tool set to verify signed JAR files.

Typically, verification of signed JAR files will be the responsibility of your Java™ Runtime Environment. Your browser will verify signed applets that it downloads. Signed applications invoked with the -jar option of the interpreter will be verified by the runtime environment.

However, you can verify signed JAR files yourself by using the Jarsigner tool. You might want to do this, for example, to test a signed JAR file that you've prepared.

The basic command to use for verifying a signed JAR file is:

jarsigner -verify jar-file

This command will verify the JAR file's signature and ensure that the files in the archive haven't changed since it was signed. You'll see the following message if the verification is successful:

jar verified.

If you try to verify an unsigned JAR file, the following message results:

jar is unsigned. (signatures missing or not parsable)

If the verification fails, an appropriate message is displayed. For example, if the contents of a JAR file have changed since the JAR file was signed, a message similar to the following will result if you try to verify the file:

jarsigner: java.lang.SecurityException: invalid SHA1 
signature file digest for test/classes/Manifest.class

Using JAR related API

The Java platform contains several classes for use with JAR files. Some of these APIs are:

1. The java.util.jar package
2. The java.net.JarURLConnection class
3. The java.net.URLClassLoader class

To give you an idea of the possibilities that are opened up by these new APIs, this lesson guides you through the inner workings of a sample application called JarRunner.

An Example - The JarRunner Application

JarRunner enables you to run an application that's bundled in a JAR file by specifying the JAR file's URL on the command line. For example, if an application called TargetApp were bundled in a JAR file at http://www.example.com/TargetApp.jar, you could run the application using this command:

$ java JarRunner http://www.example.com/TargetApp.jar

In order for JarRunner to work, it must be able to perform the following tasks, all of which are accomplished by using the new APIs:

• Access the remote JAR file and establish a communications link with it.
• Inspect the JAR file's manifest to see which of the classes in the archive is the main class.
• Load the classes in the JAR file.

The JarRunner application consists of two classes, JarRunner and JarClassLoader. JarRunner delegates most of the JAR-handling tasks to the JarClassLoader class. JarClassLoader extends the java.net.URLClassLoader class. You can browse the source code for the JarRunner and JarClassLoader classes before proceeding with the lesson:

• JarRunner.java

import java.io.IOException;

import java.net.URL;

import java.net.MalformedURLException;

import java.lang.reflect.InvocationTargetException;

/**

 * Runs a jar application from any url. Usage is 'java JarRunner url [args..]'

 * where url is the url of the jar file and args is optional arguments to

 * be passed to the application's main method.

 */

public class JarRunner {

    public static void main(String[] args) {

        if (args.length < 1) {

            usage();

        }

        URL url = null;

        try {

            url = new URL(args[0]);

        } catch (MalformedURLException e) {

            fatal("Invalid URL: " + args[0]);

        }

        // Create the class loader for the application jar file

        JarClassLoader cl = new JarClassLoader(url);

        // Get the application's main class name

        String name = null;

        try {

            name = cl.getMainClassName();

        } catch (IOException e) {

            System.err.println("I/O error while loading JAR file:");

            e.printStackTrace();

            System.exit(1);

        }

        if (name == null) {

            fatal("Specified jar file does not contain a 'Main-Class'" +

                  " manifest attribute");

        }

        // Get arguments for the application

        String[] newArgs = new String[args.length - 1];

        System.arraycopy(args, 1, newArgs, 0, newArgs.length);

        // Invoke application's main class

        try {

            cl.invokeClass(name, newArgs);

        } catch (ClassNotFoundException e) {

            fatal("Class not found: " + name);

        } catch (NoSuchMethodException e) {

            fatal("Class does not define a 'main' method: " + name);

        } catch (InvocationTargetException e) {

            e.getTargetException().printStackTrace();

            System.exit(1);

        }

    }

    private static void fatal(String s) {

        System.err.println(s);

        System.exit(1);

    }

    private static void usage() {

        fatal("Usage: java JarRunner url [args..]");

    }

}

• JarClassLoader.java

import java.net.URL;

import java.net.URLClassLoader;

import java.net.JarURLConnection;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.InvocationTargetException;

import java.util.jar.Attributes;

import java.io.IOException;

/**

 * A class loader for loading jar files, both local and remote.

 */

class JarClassLoader extends URLClassLoader {

    private URL url;

    /**

     * Creates a new JarClassLoader for the specified url.

     * @param url the url of the jar file

     */

    public JarClassLoader(URL url) {

        super(new URL[] { url });

        this.url = url;

    }

    /**

     * Returns the name of the jar file main class, or null if

     * no "Main-Class" manifest attributes was defined.

     */

    public String getMainClassName() throws IOException {

        URL u = new URL("jar", "", url + "!/");

        JarURLConnection uc = (JarURLConnection)u.openConnection();

        Attributes attr = uc.getMainAttributes();

        return attr != null ? attr.getValue(Attributes.Name.MAIN_CLASS) : null;

    }

    /**

     * Invokes the application in this jar file given the name of the main class and an array of arguments. The class must define a

     * static method "main" which takes an array of String arguments and is of return type "void".

     *

     * @param name the name of the main class

     * @param args the arguments for the application

     * @exception ClassNotFoundException if the specified class could not be found

     * @exception NoSuchMethodException if the specified class does not contain a "main" method

     * @exception InvocationTargetException if the application raised an exception

     */

    public void invokeClass(String name, String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException {

        Class c = loadClass(name);

        Method m = c.getMethod("main", new Class[] { args.getClass() });

        m.setAccessible(true);

        int mods = m.getModifiers();

        if (m.getReturnType() != void.class || !Modifier.isStatic(mods) ||

            !Modifier.isPublic(mods)) {

            throw new NoSuchMethodException("main");

        }

        try {

            m.invoke(null, new Object[] { args });

        } catch (IllegalAccessException e) {

            // This should not happen, as we have disabled access checks

        }

    }

}

This lesson has two parts:

The JarClassLoader Class: This section shows you how JarClassLoader uses some of the new APIs to perform tasks required for the JarRunner application to work.

The JarRunner Class: This section summarizes the JarRunner class that comprises the JarRunner application.

Question & Answer

Q: How do you invoke an applet that is packaged as a JAR file?

Ans: To invoke an applet packaged as a JAR file, open a page containing the applet:

<applet code="AppletClassName.class" archive="JarFileName.jar" width=320 height=240></applet>

Q: What is the purpose of the -e option in a jar command?

Ans: This option is available since Java SE 6. It sets the entry point as the application entry point for stand-alone applications bundled into executable jar file. The use of this option creates or overrides the Main-Class attribute value in the manifest file. This option can be used during creation of jar file or while updating the jar file. This option specifies the application entry point without editing or creating the manifest file. For example, this command creates Main.jar where the Main-Class attribute value in the manifest is set to Main: 

$ jar cfe Main.jar Main Main.class

Q: What is the significance of the manifest in a JAR file?

Ans: A JAR file's manifest provides meta-information about the other contents of the JAR file. The manifest itself resides in META-INF/MANIFEST.mf. The meta-information can include:

• Dependencies on other jar files
• The name of a class to run when "java -jar file.jar" is invoked
• versioning information
• Security information

Q: How do you modify a JAR's manifest file?

Ans: Typically, modifying the default manifest involves adding special-purpose headers to the manifest that allow the JAR file to perform a particular desired function.

To modify the manifest, you must first prepare a text file with a complete and valid manifest file. You then use the JAR tool's m option to add the information in your file to the manifest.

The manifest file your prepare must end with a new line or carriage return. The last line will not be parsed properly if it does not end with a new line or carriage return.