development/proposals/FlexibleProjectConcepts.html - gerrit/www.eclipse.org/webtools - Git at Google

 <html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><link type="text/css" href="../../../default_style.css" rel="stylesheet"><link type="text/css" href="../../../webtools/wtp.css" rel="stylesheet"><title>flexible project concepts</title></head><body><table border="0" cellpadding="2" cellspacing="5" width="100%"><tbody><tr><td align="left" width="60%"><font class="indextop">jst j2ee</font><br><font class="indexsub">flexible project concepts</font></td><td width="40%"><img src="../../../webtools/images/wtplogosmall.jpg" align="middle" height="129" hspace="50" width="207" alt="WTP Logo" usemap="logomap"><map id="logomap" name="logomap"><area coords="0,0,207,129" href="/webtools/" alt="WTP Home"></map></td></tr></tbody></table><table border="0" cellpadding="2" cellspacing="5" width="100%"><col width="16"><col width="*"><tbody><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><a name="top"></a></td></tr><tr><td colspan="2" align="left" bgcolor="#0080c0" valign="top"><b><font color="#ffffff" face="Arial,Helvetica">Introduction</font></b></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			The goal of this document is to share some initial ideas that will help
 			shape the Eclipse Web Tools (WTP) J2EE project application model and its
 			implementation. We initially planned to pursue this effort as a formal
 			requirements gathering and documentation process. But once we began
 			analyzing the problem space it was clear that there is no common J2EE
 			project model used within the J2EE development community. Stated another
 			way, all current J2EE project models are ad hoc. At most, the J2EE
 			application deployment model, defined in the J2EE specification, is the
 			only common reference structure and it only specifies to the runtime
 			archive form of valid J2EE applications. With that as our starting point,
 			we concluded that rather than attempt to draft a conventional
 			requirements document, it would be more beneficial to initiate a
 			discussion of ideas among the key WTP participants that can serve as the
 			catalyst for a J2EE application project requirements and subsequent
 			architecture and implementation.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			The contents of this document are representative of the future direction.
 			However, some of this functionality described is representative of our
 			current state.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			There are several use cases described in the Use Case Scenario Powerpoint
 			Slides. Where relevant, the relationship of the concepts described in
 			this document and the scenario slides are highlighted.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			A
 			<b>project</b>
 			is a type of resource which groups resources into buildable, reusable
 			units - Java project resources are defined in terms of Java elements such
 			as package fragments, types, methods and fields.

 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>The scenario slides highlight the following types of use cases:</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><ul>
 			<li>
 				<p>Simple Project (contains one module and one Deploy Scheme)</p>
 			</li>
 			<li>
 				<p>
 					Simple Container Project (contains one or more modules, possibly
 					multiple Deploy Schemes)
 				</p>
 			</li>
 			<li>
 				<p>
 					Application Project (application and modules contained in the
 					same Simple Container project)
 				</p>
 			</li>
 			<li>
 				<p>
 					Application Project Variation (application in one Simple
 					Container Project modules may be in other Simple Container
 					projects)
 				</p>
 			</li>
 			<li>
 				<p>Composed Modules (stay tuned (bum bum bum))</p>
 			</li>
 		</ul></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			The J2EE module definitions build on the use case concepts. As discussed
 			in the use cases, a module is a collection of files in a project.
 			However, for the remainder of this document, the term abstract module
 			will refer to an intangible concept (to be defined more explicitly later
 			on). The abstract module concept represents the abstraction of a physical
 			module in terms that can be understood programmatically. The specifics of
 			how these projects are constructed is not important to the discussion of
 			modules.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			A
 			<b>resource</b>
 			is a abstraction which contains model elements. A
 			<b>resource set</b>
 			is a collection of related persistent resources. The resource set manages
 			the collection of resources and produces notifications for changes to
 			that collection. A
 			<b>project resource set</b>
 			is a resource set defined at the project level, meaning the project
 			resource set manages the collection of resources for that project. There
 			is only one project resource set per project, ensuring each resource is
 			only loaded once within the workspace. Each resource contained in the
 			project resource set has a
 			<b>relative URI</b>
 			, which is a partial URI with respect to or relative to the project. A
 			<b>WTP project resource set</b>
 			is defined in terms of module resources, which contain abstract module
 			models (defined later).
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			A
 			<b>URI converter</b>
 			may be configured on a resource set to normalize relative URIs for
 			comparison and to monitor access to the backing store. The resource set
 			will use this converter to produce an input or output stream for a URI,
 			during serialization or deserialization of a resource, and during a load
 			to check for a resource URI match to one of its known resources.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			An
 			<b>abstract module</b>
 			is a logical, abstracted, first-class model of a deployable artifact. The
 			initial assumption will be that abstract modules must be contained within
 			one project and thus use one project resource set. However, a project and
 			the associated project resource set may contain more than one abstract
 			module.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			A
 			<b>J2EE abstract module</b>
 			is a collection of one or more components, organized by a standard
 			layout, targeted for the same container upon deployment, and which can be
 			archived conforming to the J2EE specification. Modules always contain a
 			set of files, but all J2EE modules also contain specialized files called
 			<b>deployment descriptors</b>
 			. Deployment descriptors describe the contents of deployment units and
 			configure components and applications to their environment. They also
 			externalize the relationships between components, so those relationships
 			can be managed without writing or changing program code. There are five
 			core types of J2EE deployment descriptors, each of which corresponds to a
 			type of J2EE deployment unit:
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><ul>
 			<li>
 				<p>Application</p>
 			</li>
 			<li>
 				<p>Application Client</p>
 			</li>
 			<li>
 				<p>EJB</p>
 			</li>
 			<li>
 				<p>Web</p>
 			</li>
 			<li>
 				<p>Resource Adapter for Java Connector</p>
 			</li>
 		</ul></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			Vendor-specific deployment descriptors may be defined for different
 			Enterprise application containers to provide additional information.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			Each deployment descriptor describes a set of contained objects which are
 			represented through
 			<b>module models</b>
 			. The root abstract module model object for the deployment descriptor is
 			the associated J2EE abstract module type object.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><ul>
 			<li>
 				<p>
 					The
 					<b>Application</b>
 					is the root object for an EAR module.
 				</p>
 			</li>
 			<li>
 				<p>
 					The
 					<b>EJBJar</b>
 					is the root object for an EJB module.
 				</p>
 			</li>
 			<li>
 				<p>
 					The
 					<b>WebApp</b>
 					is the root object for a Web module
 				</p>
 			</li>
 			<li>
 				<p>
 					The
 					<b>ApplicationClient</b>
 					is the root object for an Application Client module.
 				</p>
 			</li>
 			<li>
 				<p>
 					The
 					<b>Connector</b>
 					is the root object for a JCA Connector module.
 				</p>
 			</li>
 		</ul></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			Before proceeding, it should be noted that there are two distinct
 			metamodels in the tooling environment. First, J2EE abstract models allow
 			framework clients to understand the J2EE-specific deployment descriptors
 			and their third-party extensions. The tooling frameworks are built
 			primarily to modify and update these models. There is also a separate
 			model for understanding how modules and their contained resources can be
 			constructed for deploying to server environments, which is referred to as
 			<b>ModuleCore</b>
 			.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			<b>ModuleCore</b>
 			can be used to acquire, create, and destroy
 			<b>abstract module contexts</b>
 			. An
 			<b>abstract module context</b>
 			is used to manage multiple abstract modules per project. In the first
 			implementation, an abstract module context will not span multiple
 			projects. Each abstract module context identifies a unique custom defined
 			abstract module using a module handle (see Server Tooling), server target
 			type (see Server Tooling), an edit model (to be discussed later).

 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><table cellspacing="10" cellpadding="10">
 			<tr>
 				<td>
 					<p>

 					</p>
 				</td>
 			</tr>
 			<tr>
 				<td>
 					<p>
 						<i>
 							Figure 1: Overview of ModuleCore, ModuleContext, and
 							Abstract Module relationships.
 						</i>
 					</p>
 				</td>
 			</tr>
 		</table></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			Meanwhile,
 			<b>edit models</b>
 			provide a shared, reference counted, read/write controlled amalgamation
 			of a related set of resources. Primarily, resources and Java working
 			copies are wrapped by an Edit Model in order to represent a coherent and
 			consistent view for clients. Managing these resources as a group, allows
 			changes to be committed or rolled back as a consistent unit of work.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			Typically, specialized types of edit models have aforementioned knowledge
 			of their expected or required resources for a given type of abstracted
 			module. Not surprisingly, clients may wish to add capabilities and
 			additional known resources to existing edit model. The edit model will
 			attempt to load these resources so that they may be managed with the
 			existing, known resources.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			Edit models are created via an extension which defines the
 			<b>edit model factory</b>
 			. The lifecycle of how edit models are created and destroyed will be
 			covered in the API Concepts document.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			Typically, J2EE components are built on a regular schedule (e.g. daily)
 			and packaged as Enterprise Archives (EARs). Collaboration between teams
 			and individual members is facilitated by these build artifacts which are
 			used to back current development. These are referred to as
 			<b>target EARs</b>
 			. Developers set up their development environments so the components they
 			are actively working on are loaded directly from a source repository and
 			the other components are loaded from the Target EARs.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			The use of target EARs is analogous to self-hosting in Eclipse. The idea
 			is to only have abstract modules that are currently being developed in
 			the workspace. All other dependencies will be loaded from a target EAR.
 			Changing target EARs would simply be a matter of adjusting some abstract
 			module property (just like PDE). Loading projects from the repository, or
 			deleting them from the workspace would change where they were loaded from
 			as well (also like PDE).
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			Rather than using target EARs, EAR files may be extracted to a structure
 			which represents its contained abstract modules. The remaining non-module
 			jar archives are called
 			<b>utility jars</b>
 			. Utility jars are regular jars which the various abstract modules can
 			depend on. Utility jars may exist as jar files within the EAR abstract
 			module which is useful when a developer is not currently working on the
 			contents of the utility jar. All abstract module archives must (utility
 			jars have the option) be handled in separate abstract modules.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p>
 			An <b>extracted module</b> or <b>utility jar module</b> is simply a module containing
 			the extracted contents of the archive. The benefit of using extracted
 			modules is all the artifacts can be modified. This would be useful if a
 			developer did not have access to the source repository. Typically,
 			however, instead of using extracted modules, a developer would connect to
 			a source repository. Jars within WARs can be extracted as modules within
 			Eclipse projects (like utility jar modules) or can remain in the WAR in
 			binary form.
 		</p></td></tr><tr><td align="right" valign="top">
                 &nbsp;
             </td><td valign="top"><p><i>Last updated 11/11/04</i></p></td></tr></tbody></table></body></html>
	<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><link type="text/css" href="../../../default_style.css" rel="stylesheet"><link type="text/css" href="../../../webtools/wtp.css" rel="stylesheet"><title>flexible project concepts</title></head><body><table border="0" cellpadding="2" cellspacing="5" width="100%"><tbody><tr><td align="left" width="60%"><font class="indextop">jst j2ee</font><br><font class="indexsub">flexible project concepts</font></td><td width="40%"><img src="../../../webtools/images/wtplogosmall.jpg" align="middle" height="129" hspace="50" width="207" alt="WTP Logo" usemap="logomap"><map id="logomap" name="logomap"><area coords="0,0,207,129" href="/webtools/" alt="WTP Home"></map></td></tr></tbody></table><table border="0" cellpadding="2" cellspacing="5" width="100%"><col width="16"><col width="*"><tbody><tr><td align="right" valign="top">

	</td><td valign="top"><a name="top"></a></td></tr><tr><td colspan="2" align="left" bgcolor="#0080c0" valign="top"><b><font color="#ffffff" face="Arial,Helvetica">Introduction</font></b></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	The goal of this document is to share some initial ideas that will help
	shape the Eclipse Web Tools (WTP) J2EE project application model and its
	implementation. We initially planned to pursue this effort as a formal
	requirements gathering and documentation process. But once we began
	analyzing the problem space it was clear that there is no common J2EE
	project model used within the J2EE development community. Stated another
	way, all current J2EE project models are ad hoc. At most, the J2EE
	application deployment model, defined in the J2EE specification, is the
	only common reference structure and it only specifies to the runtime
	archive form of valid J2EE applications. With that as our starting point,
	we concluded that rather than attempt to draft a conventional
	requirements document, it would be more beneficial to initiate a
	discussion of ideas among the key WTP participants that can serve as the
	catalyst for a J2EE application project requirements and subsequent
	architecture and implementation.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	The contents of this document are representative of the future direction.
	However, some of this functionality described is representative of our
	current state.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	There are several use cases described in the Use Case Scenario Powerpoint
	Slides. Where relevant, the relationship of the concepts described in
	this document and the scenario slides are highlighted.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	A
	<b>project</b>
	is a type of resource which groups resources into buildable, reusable
	units - Java project resources are defined in terms of Java elements such
	as package fragments, types, methods and fields.

	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>The scenario slides highlight the following types of use cases:</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><ul>
	<li>
	<p>Simple Project (contains one module and one Deploy Scheme)</p>
	</li>
	<li>
	<p>
	Simple Container Project (contains one or more modules, possibly
	multiple Deploy Schemes)
	</p>
	</li>
	<li>
	<p>
	Application Project (application and modules contained in the
	same Simple Container project)
	</p>
	</li>
	<li>
	<p>
	Application Project Variation (application in one Simple
	Container Project modules may be in other Simple Container
	projects)
	</p>
	</li>
	<li>
	<p>Composed Modules (stay tuned (bum bum bum))</p>
	</li>
	</ul></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	The J2EE module definitions build on the use case concepts. As discussed
	in the use cases, a module is a collection of files in a project.
	However, for the remainder of this document, the term abstract module
	will refer to an intangible concept (to be defined more explicitly later
	on). The abstract module concept represents the abstraction of a physical
	module in terms that can be understood programmatically. The specifics of
	how these projects are constructed is not important to the discussion of
	modules.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	A
	<b>resource</b>
	is a abstraction which contains model elements. A
	<b>resource set</b>
	is a collection of related persistent resources. The resource set manages
	the collection of resources and produces notifications for changes to
	that collection. A
	<b>project resource set</b>
	is a resource set defined at the project level, meaning the project
	resource set manages the collection of resources for that project. There
	is only one project resource set per project, ensuring each resource is
	only loaded once within the workspace. Each resource contained in the
	project resource set has a
	<b>relative URI</b>
	, which is a partial URI with respect to or relative to the project. A
	<b>WTP project resource set</b>
	is defined in terms of module resources, which contain abstract module
	models (defined later).
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	A
	<b>URI converter</b>
	may be configured on a resource set to normalize relative URIs for
	comparison and to monitor access to the backing store. The resource set
	will use this converter to produce an input or output stream for a URI,
	during serialization or deserialization of a resource, and during a load
	to check for a resource URI match to one of its known resources.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	An
	<b>abstract module</b>
	is a logical, abstracted, first-class model of a deployable artifact. The
	initial assumption will be that abstract modules must be contained within
	one project and thus use one project resource set. However, a project and
	the associated project resource set may contain more than one abstract
	module.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	A
	<b>J2EE abstract module</b>
	is a collection of one or more components, organized by a standard
	layout, targeted for the same container upon deployment, and which can be
	archived conforming to the J2EE specification. Modules always contain a
	set of files, but all J2EE modules also contain specialized files called
	<b>deployment descriptors</b>
	. Deployment descriptors describe the contents of deployment units and
	configure components and applications to their environment. They also
	externalize the relationships between components, so those relationships
	can be managed without writing or changing program code. There are five
	core types of J2EE deployment descriptors, each of which corresponds to a
	type of J2EE deployment unit:
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><ul>
	<li>
	<p>Application</p>
	</li>
	<li>
	<p>Application Client</p>
	</li>
	<li>
	<p>EJB</p>
	</li>
	<li>
	<p>Web</p>
	</li>
	<li>
	<p>Resource Adapter for Java Connector</p>
	</li>
	</ul></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	Vendor-specific deployment descriptors may be defined for different
	Enterprise application containers to provide additional information.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	Each deployment descriptor describes a set of contained objects which are
	represented through
	<b>module models</b>
	. The root abstract module model object for the deployment descriptor is
	the associated J2EE abstract module type object.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><ul>
	<li>
	<p>
	The
	<b>Application</b>
	is the root object for an EAR module.
	</p>
	</li>
	<li>
	<p>
	The
	<b>EJBJar</b>
	is the root object for an EJB module.
	</p>
	</li>
	<li>
	<p>
	The
	<b>WebApp</b>
	is the root object for a Web module
	</p>
	</li>
	<li>
	<p>
	The
	<b>ApplicationClient</b>
	is the root object for an Application Client module.
	</p>
	</li>
	<li>
	<p>
	The
	<b>Connector</b>
	is the root object for a JCA Connector module.
	</p>
	</li>
	</ul></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	Before proceeding, it should be noted that there are two distinct
	metamodels in the tooling environment. First, J2EE abstract models allow
	framework clients to understand the J2EE-specific deployment descriptors
	and their third-party extensions. The tooling frameworks are built
	primarily to modify and update these models. There is also a separate
	model for understanding how modules and their contained resources can be
	constructed for deploying to server environments, which is referred to as
	<b>ModuleCore</b>
	.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	<b>ModuleCore</b>
	can be used to acquire, create, and destroy
	<b>abstract module contexts</b>
	. An
	<b>abstract module context</b>
	is used to manage multiple abstract modules per project. In the first
	implementation, an abstract module context will not span multiple
	projects. Each abstract module context identifies a unique custom defined
	abstract module using a module handle (see Server Tooling), server target
	type (see Server Tooling), an edit model (to be discussed later).

	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><table cellspacing="10" cellpadding="10">
	<tr>
	<td>
	<p>

	</p>
	</td>
	</tr>
	<tr>
	<td>
	<p>
	<i>
	Figure 1: Overview of ModuleCore, ModuleContext, and
	Abstract Module relationships.
	</i>
	</p>
	</td>
	</tr>
	</table></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	Meanwhile,
	<b>edit models</b>
	provide a shared, reference counted, read/write controlled amalgamation
	of a related set of resources. Primarily, resources and Java working
	copies are wrapped by an Edit Model in order to represent a coherent and
	consistent view for clients. Managing these resources as a group, allows
	changes to be committed or rolled back as a consistent unit of work.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	Typically, specialized types of edit models have aforementioned knowledge
	of their expected or required resources for a given type of abstracted
	module. Not surprisingly, clients may wish to add capabilities and
	additional known resources to existing edit model. The edit model will
	attempt to load these resources so that they may be managed with the
	existing, known resources.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	Edit models are created via an extension which defines the
	<b>edit model factory</b>
	. The lifecycle of how edit models are created and destroyed will be
	covered in the API Concepts document.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	Typically, J2EE components are built on a regular schedule (e.g. daily)
	and packaged as Enterprise Archives (EARs). Collaboration between teams
	and individual members is facilitated by these build artifacts which are
	used to back current development. These are referred to as
	<b>target EARs</b>
	. Developers set up their development environments so the components they
	are actively working on are loaded directly from a source repository and
	the other components are loaded from the Target EARs.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	The use of target EARs is analogous to self-hosting in Eclipse. The idea
	is to only have abstract modules that are currently being developed in
	the workspace. All other dependencies will be loaded from a target EAR.
	Changing target EARs would simply be a matter of adjusting some abstract
	module property (just like PDE). Loading projects from the repository, or
	deleting them from the workspace would change where they were loaded from
	as well (also like PDE).
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	Rather than using target EARs, EAR files may be extracted to a structure
	which represents its contained abstract modules. The remaining non-module
	jar archives are called
	<b>utility jars</b>
	. Utility jars are regular jars which the various abstract modules can
	depend on. Utility jars may exist as jar files within the EAR abstract
	module which is useful when a developer is not currently working on the
	contents of the utility jar. All abstract module archives must (utility
	jars have the option) be handled in separate abstract modules.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p>
	An <b>extracted module</b> or <b>utility jar module</b> is simply a module containing
	the extracted contents of the archive. The benefit of using extracted
	modules is all the artifacts can be modified. This would be useful if a
	developer did not have access to the source repository. Typically,
	however, instead of using extracted modules, a developer would connect to
	a source repository. Jars within WARs can be extracted as modules within
	Eclipse projects (like utility jar modules) or can remain in the WAR in
	binary form.
	</p></td></tr><tr><td align="right" valign="top">

	</td><td valign="top"><p><i>Last updated 11/11/04</i></p></td></tr></tbody></table></body></html>