<?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 3.0 and EJB 3.1 architecture" />
<meta name="abstract" content="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." />
<meta name="description" content="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." />
<meta content="architecture, EJB 3.0 and EJB 3.1, 3.0" name="DC.subject" />
<meta content="architecture, EJB 3.0 and EJB 3.1, 3.0" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../topics/ceover.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/cpojosandee5.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/cejb3vejb21.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="ejbarch" 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 3.0 and EJB 3.1 architecture</title>
</head>
<body id="ejbarch"><a name="ejbarch"><!-- --></a>


<h1 class="topictitle1">EJB 3.0 and EJB 3.1 architecture</h1>



<div><p>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.</p>

<p><strong>Enterprise JavaBeans</strong> is a standard
server-side component model for distributed business applications.
The EJB specification is part of the <strong>Java™ Platform
Enterprise Edition</strong>.</p>

<p><strong>EJB 3.0 and EJB 3.1</strong> makes it much easier to develop EJBs,
using annotations rather than the complex deployment descriptors used
in version 2.x. The use of home and remote interfaces and the <em>ejb-jar.xml</em> file
are also no longer required in this release. They are replaced with
a business interface and a bean class that implements the interface.</p>

<p>For more information about EJB 3.0 and EJB 3.1 specification go
to the following Web site: <a href="http://java.sun.com/products/ejb/docs.html#specs" target="_blank" title="">http://java.sun.com</a> </p>

</div>

<div>
<ul class="ullinks">
<li class="ulchildlink"><strong><a href="../topics/cpojosandee5.html">Plain old Java objects</a></strong><br />
Although POJOs existed before, they play a more important role in the programming methodology of Java EE 5. Now, you can now create EJB applications with persistence capabilities by using enterprise beans and entities created from POJOs.</li>
<li class="ulchildlink"><strong><a href="../topics/cejb3vejb21.html">Differences between EJB 3.0 and EJB 2.1</a></strong><br />
Compared to EJB 2.1, EJB 3.0 simplifies the process of creating Enterprise JavaBean applications.</li>
</ul>

<div class="familylinks">
<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/ceover.html" title="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.">EJB 2.x application development</a></div>
</div>
</div>

</body>
</html>