<!-- ----------------------------------------------------------------------------- -->
<!-- 
Project: Web Tooling Platform (WTP) Project

Contact: David Williams (david_williams@us.ibm.com)
-->
<!-- ----------------------------------------------------------------------------- -->

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>J2EE Standard Tools (JST)</title>
<meta
	http-equiv="Content-Type"
	content="text/html; charset=iso-8859-1" />
<link
	rel="stylesheet"
	type="text/css"
	href="theme/eclipse_style.css" />
</head>
<body>

<div id="page_header">J2EE Standard Tools</div>
<div id="page_sub_header">Project architecture</div>

<div id="section_header">Project description</div>
<div class="content">
<p>The initial scope of the <a
	href="http://www.eclipse.org/webtools/jst/main.html">J2EE Standard Tools</a>
subproject will be to provide a to provide common infrastructure for
developing applications based on J2EE 1.4 targeting J2EE-compliant
application servers, as well as a more generic J2EE tooling
infrastructure for other Eclipse-based development products.</p>
<p>Tools provided will include a workbench for developing, deploying,
testing and debugging J2EE applications on JCP-compliant server
environments, as well as an exemplary implementation of a plug-in for at
least one JSR-88 compliant J2EE Server. Included will be a range of
tools simplifying development with J2EE APIs including EJB, Servlet,
JSP, JCA, JDBC, JTA, JMS, JMX, JNDI, and Web Services. This
infrastructure will be architected for extensibility for higher-level
development constructs providing architectural separations of concern
and technical abstraction above the level of the J2EE specifications</p>
<p>The integrated workbench to be delivered would support use cases such
as " - Develop a JSP page, Enhance the "PetStore" blue-print
application, Expose a Session Bean as a Web Service".</p>

<p>Refer to the <a href="wtp_project_main.html">WTP Project overview</a>
for additional WTP Project information. You can click on the image below
for additional information for the subsystems of JST</p>
</div>


<!-- Remove this section if you do not have an additional diagram -->
<div id="section_header">Project architecture</div>
<div class="image_map"><img
	src="images/jstsubsystems.jpg"
	width="497"
	height="421"
	usemap="#jstsubsystems"
	alt="" /><map
	id="jstsubsystems"
	name="jstsubsystems">
	<area
		shape="rect"
		href="#JSTServer"
		coords="384,201,481,276"
		alt="" />
	<area
		shape="rect"
		href="#BasicJ2EE"
		coords="293,118,407,192"
		alt="" />
	<area
		shape="rect"
		href="#AdvancedJ2EE"
		coords="201,30,337,107"
		alt="" />
	<area
		shape="rect"
		href="#JSP"
		coords="97,119,195,188"
		alt="" />
	<area
		shape="default"
		nohref="nohref"
		alt="" />
</map><span class="img_caption">Figure 1. JST Subsystems</span></div>

<div id="section_header">JST Subsystem descriptions</div>
<div class="content">
<dl id="subsys_list">
	<dt><a name="JSTServer">Server Subsystem</a></dt>
	<dd>This subsystem has components associated with servering, browsing,
	and monitoring web resources.
	<p>This subsystem has the following components:</p>
	<table id="tbl_info">
		<tr>
			<th id="name">Name</th>
			<th id="desc">Description</th>
		</tr>
		<tr>
			<td headers="name"><a href="http://www.eclipse.org/webtools/jst/components.html#jstserver">Server</a></td>
			<td headers="desc">The server component contains the J2EE Server
			Tools framework and adapters for selected popular J2EE servers such
			as Apache Tomcat. The component leads are Naci Dai and Tim deBoer.</td>
		</tr>
	</table>
	</dd>
	<dt><a name="JSP">JSP Subsystem</a></dt>
	<dd>Models and UI needed for developing JSP resources.
	<p>This subsystem has the following components:</p>
	<table id="tbl_info">
		<tr>
			<th id="name">Name</th>
			<th id="desc">Description</th>
		</tr>
		<tr>
			<td headers="name"><a href="http://www.eclipse.org/webtools/jst/components.html#jsp">JSP</a></td>
			<td headers="desc">The jsp component contains the JSP editor, model,
			views, wizards, etc. The component lead is David Williams.</td>
		</tr>
	</table>
	</dd>
	<dt><a name="BasicJ2EE">Basic J2EE Subsystem</a></dt>
	<dd>This Subsystem contains models, UI, and Tools, for basic J2EE
	development, such as servlets.
	<p>This subsystem has the following components:</p>
	<table id="tbl_info">
		<tr>
			<th id="name">Name</th>
			<th id="desc">Description</th>
		</tr>
		<tr>
			<td headers="name"><a href="http://www.eclipse.org/webtools/jst/components.html#servlet">Servlet</a></td>
			<td headers="desc">The servlet component contains the servlet
			editors, models, views, wizards, etc. The component lead is Naci Dai.</td>
		</tr>
		<tr>
			<td headers="name"><a href="http://www.eclipse.org/webtools/jst/components.html#j2ee">J2EE</a></td>
			<td headers="desc">The jst project component contains common j2ee
			models, natures and builders for J2EE projects, and j2ee modules
			views, wizards, etc. including the new support for flexible project
			layouts. The component leads are Naci Dai and Chuck Bridgham.</td>
		</tr>
	</table>
	</dd>
	<dt><a name="AdvancedJ2EE">Advanced J2EE Subsystem</a></dt>
	<dd>Models, UI, and Tools to support development of EJBs and J2EE Web
	Services.
	<p>This subsystem has the following components:</p>
	<table id="tbl_info">
		<tr>
			<th id="name">Name</th>
			<th id="desc">Description</th>
		</tr>
		<tr>
			<td headers="name"><a href="http://www.eclipse.org/webtools/jst/components.html#ejb">EJB</a></td>
			<td headers="desc">The ejb component contains the ejb editors,
			models, views, wizards, etc. The component lead is Naci Dai.</td>
		</tr>
		<tr>
			<td headers="name"><a href="http://www.eclipse.org/webtools/jst/components.html#ws">WS</a></td>
			<td headers="desc">The ws component contains the Java Web service
			wizard and adapters for selected popular J2EE Web service engines
			such as Apache Axis. The component lead is Chris Brealey.</td>
		</tr>
	</table>
	</dd>
	<dd>
	<p></p>

	</dd>

	<!-- template version to use in above table
	<dt>&lt;subsystem&gt;</dt>
	<dd>&lt;descriptions&gt;
	<p>This subsystem has the following components:</p>
	<table id="tbl_info">
		<tr>
			<th id="name">Name</th>
			<th id="desc">Description</th>
		</tr>
		<tr>
			<td headers="name">org.eclipse.wtp.releng</td>
			<td headers="desc">Build infrastructure, map files</td>
		</tr>
		<tr>
			<td headers="name">performance</td>
			<td headers="desc">custom performance tests</td>
		</tr>
		<tr>
			<td headers="name">test</td>
			<td headers="desc">junit test infrastructure</td>
		</tr>
	</table>
	</dd>
-->


</dl>
</div>

<div class="section_divider"></div>
<div class="content">
<div id="copyright">See <a
	href="http://www.eclipse.org/legal/termsofuse.html">Terms of Use</a>.
</div>
</div>
</body>
</html>
