<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<!-- /*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/ -->
<link rel="stylesheet" type="text/css" href="../../org.eclipse.wst.doc.user/common.css" />
<title>Application client projects</title>
</head>
<body id="cjappcliproj"><a name="cjappcliproj"><!-- --></a>

<h1 class="topictitle1">Application client projects</h1>
<div><p>Application client projects contain the resources needed for application
client modules. An application client module is used to contain a full-function
client Java™ application (non Web-based) that connects to and
uses the J2EE resources defined in your server. When you place the client
code in an application client module instead of a simple JAR file, the application
client benefits from the server's resources (it does not need to re-specify
the class path to J2EE and server JAR files) as well as from easier JNDI lookup
(the client container fills in the initial context and other parameters).
The application client project allows you to work as if you are creating a
standalone Java application in a Java project.</p>
<p>An application client project enables you to do the following things:</p>
<ul><li>Develop the Java classes that implement the client module</li>
<li>Set the application client deployment descriptor</li>
<li>Test the application client</li>
</ul>
<p>Like Java projects, application client projects contain the
resources needed for application clients, including Java class
files. When you create a new application client project, the environment is
set up for Java development. A Java <em>builder</em> is associated with the
project so the Java source can be incrementally compiled as it is updated.
The application client project contains information about the type hierarchy
and Java elements.
This information is kept current as changes are made, and the Java builder
will incrementally compile the resources within these projects as the resources
are updated.</p>
<p>In the workbench, application client projects are always referenced by
enterprise application (EAR) projects. When you create an application client
project, you specify the enterprise application project to which the application
client project belongs. A module element is automatically added to the <samp class="codeph">application.xml</samp> deployment
descriptor for the EAR project.</p>
<p>An application client project is deployed as a JAR file. This application
client JAR file contains the necessary resources for the application, including Java class
files, and deployment descriptor information and any meta-data extensions
and bindings files.</p>
<p>Application client projects are typically run on networked client systems
connected to J2EE (EJB) servers. The point of entry for the application client
is a Java main-class,
which is simply a Java class that contains a static main method. The class
is declared in the manifest file of the client module. </p>
<p>A J2EE application client container provides access to the J2EE service
(JNDI naming services, deployment services, transaction services, and security
services) and communications APIs (internet protocols, Remote Method Invocation
protocols, Object Management Group protocols, Messaging protocols, and data
formats).</p>
<p>By default, application client projects contain one folder named <span class="uicontrol">appClientModule</span>,
which contains both Java source code and compiled <samp class="codeph">.class</samp> files,
along with all the meta-data files in the <span class="uicontrol">META-INF</span> subfolder.</p>
</div>
<div><div class="relconcepts"><strong>Related concepts</strong><br />
<div><a href="../topics/cjarch.html" title="The Java 2 Platform, Enterprise Edition (J2EE) provides a standard for developing multitier, enterprise services.">J2EE architecture</a></div>
</div>
<div class="reltasks"><strong>Related tasks</strong><br />
<div><a href="../topics/tjappproj.html" title="You can use a wizard to create a new application client project and add it to a new or existing enterprise application project.">Creating an application client project</a></div>
<div><a href="../topics/tjexpapp.html" title="You can export an application client project as a JAR file.">Exporting an application client project</a></div>
<div><a href="../topics/tjimpapp.html">Importing an application client JAR file</a></div>
</div>
</div>
</body>
</html>