<?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, 2011 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, 2011" />
<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="EJB 2.x application development" />
<meta name="abstract" content="The workbench provides a specialized environment that you can use to develop and test enterprise beans that conform to the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version specification. This product supports the Enterprise JavaBeans 1.1, 2.0, 2.1, and 3.0 specification levels." />
<meta name="description" content="The workbench provides a specialized environment that you can use to develop and test enterprise beans that conform to the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version specification. This product supports the Enterprise JavaBeans 1.1, 2.0, 2.1, and 3.0 specification levels." />
<meta content="applications, EJB development, EJB, developing" name="DC.subject" />
<meta content="applications, EJB development, EJB, developing" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../topics/ejbarch.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/cejb3.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/cearch.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/ceresrc.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/tecrte.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="ceover" 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>EJB 2.x application development</title>
</head>
<body id="ceover"><a name="ceover"><!-- --></a>


<h1 class="topictitle1">EJB 2.x application development</h1>



<div><p>The workbench provides a specialized environment that you can use
to develop and test enterprise beans that conform to the distributed component
architecture defined in the Sun Microsystems Enterprise JavaBeans™ (EJB)
version specification. This product supports the Enterprise JavaBeans 1.1,
2.0, 2.1, and 3.0 specification levels.</p>

<p>The complete Enterprise JavaBeans specifications and descriptions
of the technology are available from the <a href="http://java.sun.com/products/ejb/docs.html#specs" target="_blank" title="">java.sun.com</a> Web site.</p>

<p>If you are not familiar with enterprise beans or related EJB technology,
see <a href="cearch.html#cearch" title="This topic provides a high-level overview of the distributed component&#10;architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB)&#10;version 2.x architecture specification.">EJB 2.x architecture</a> for a brief description
of key EJB concepts.</p>

<p>The EJB development environment includes the following tools:</p>

<dl>
<dt class="dlterm"><strong>The Java™ EE perspective</strong></dt>

<dd>All of the EJB tools are accessible from the Java EE perspective. This perspective provides
a layout in which the most commonly used actions, views, and wizards for Java EE
and EJB development are easily accessible</dd>


<dt class="dlterm"><strong>Creating enterprise beans</strong></dt>

<dd>The EJB tools help you create enterprise beans, such as session beans
or message-driven beans. You can accomplish the following complementary enterprise
bean development activities:<ul>
<li>Writing and editing business logic.</li>

<li>Importing or exporting enterprise beans.</li>

<li>Maintaining enterprise bean source code and generated code using build
in Java development
tools, and team and version control capabilities of the workbench.</li>

</ul>
 </dd>


<dt class="dlterm"><strong>Validating enterprise bean code</strong></dt>

<dd>The EJB tools automatically validate that your enterprise bean code is
consistent and that it conforms to the rules defined by the Enterprise JavaBeans specifications.
Code verification occurs whenever an enterprise bean or its properties are
changed. Errors and warnings are displayed in the Problems view of the workbench.
Files with errors also display error icons. </dd>


<dt class="dlterm"><strong>Importing existing EJB JAR files</strong></dt>

<dd>EJB Tools allow beans and other metadata from an EJB JAR file to be imported
into a new or existing EJB project.</dd>


<dt class="dlterm"><strong>Exporting existing EJB projects into JAR files</strong></dt>

<dd>EJB tools can export your EJB project so that it may be deployed to an
application server.</dd>

</dl>

</div>

<div>
<ul class="ullinks">
<li class="ulchildlink"><strong><a href="../topics/ejbarch.html">EJB 3.0 and EJB 3.1 architecture</a></strong><br />
This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 3.0 architecture specification.</li>
<li class="ulchildlink"><strong><a href="../topics/cejb3.html">Developing EJB 3.1 Applications</a></strong><br />
You can use the workbench to develop and test enterprise beans that conform to the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) 3.10 specification.</li>
<li class="ulchildlink"><strong><a href="../topics/cearch.html">EJB 2.x architecture</a></strong><br />
This topic provides a high-level overview of the distributed component architecture defined in the Sun Microsystems Enterprise JavaBeans (EJB) version 2.x architecture specification.</li>
<li class="ulchildlink"><strong><a href="../topics/ceresrc.html">EJB 2.x development resources</a></strong><br />
This topic describes resources and development tools that are commonly used in EJB version 2.x development.</li>
<li class="ulchildlink"><strong><a href="../topics/tecrte.html">Creating enterprise beans with XDoclet annotation support</a></strong><br />
You can use a wizard to create session beans and message-driven beans that support XDoclet annotation.</li>
</ul>
</div>

</body>
</html>