<?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 content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="Copyright (c) 2000, 2009 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" />
<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="concept" name="DC.Type" />
<meta name="DC.Title" content="Application client projects" />
<meta name="abstract" content="Application client projects contain programs that run on networked client systems so the project can benefit from a server's tools." />
<meta name="description" content="Application client projects contain programs that run on networked client systems so the project can benefit from a server's tools." />
<meta content="application client projects, overview, Java EE" name="DC.subject" />
<meta content="application client projects, overview, Java EE" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../topics/cjarch.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/tjappproj.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/tjexpapp.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/tjimpapp.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="cjappcliproj" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
<title>Application client projects</title>
</head>
<body id="cjappcliproj"><a name="cjappcliproj"><!-- --></a>


<h1 class="id_title">Application client projects</h1>



<div class="id_conbody"><p class="id_shortdesc">Application client projects contain
programs that run on networked client systems so the project can benefit from
a server's tools.</p>

<p class="anchor_topictop" />

<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 Java EE 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 Java EE 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 builder 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 Java EE (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 Java EE application client container provides access to the Java EE 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>

<p class="anchor_topicbottom" />

</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 applications.">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" title="Application client projects are deployed as JAR files. You can import an application client project that has been deployed into a JAR file by using the Import wizard.">Importing an application client JAR file</a></div>
</div>
</div>

</body>
</html>