Jakarta EE Platform

Highly available

Specification: Jakarta EE Platform

Version: 11.0-M4

Status: DRAFT

Release: July 08, 2024
// The maximum number of tax exemptions, configured by the Deployer.
@Resource int maxExemptions;
// The minimum number of tax exemptions, configured by the Deployer.
@Resource int minExemptions;

public void setTaxInfo(int numberOfExemptions,...)
       throws InvalidNumberOfExemptionsException {
  ...
  // Use the environment entries to
  // customize business logic.
  if (numberOfExemptions > maxExemptions ||
         numberOfExemptions < minExemptions)
    throw new InvalidNumberOfExemptionsException();
 ...
}
// an entry that gets its value from an application-wide entry
@Resource(lookup="java:app/env/timeout") int timeout;
public void setTaxInfo(int numberOfExemptions,...)
       throws InvalidNumberOfExemptionsException {
  ...
  // Obtain the application component’s
  // environment naming context.
  Context initCtx = new InitialContext();
  Context myEnv = (Context)initCtx.lookup("java:comp/env");

  // Obtain the maximum number of tax exemptions
  // configured by the Deployer.
  Integer max = (Integer)myEnv.lookup("maxExemptions");

  // Obtain the minimum number of tax exemptions
  // configured by the Deployer.
  Integer min = (Integer)myEnv.lookup("minExemptions");

  // Use the environment entries to
  // customize business logic.
  if (numberOfExemptions > max.intValue() ||
         numberOfExemptions < min.intValue())
     throw new InvalidNumberOfExemptionsException();

  // Get some more environment entries. These environment
  // entries are stored in subcontexts.
  String val1 = (String)myEnv.lookup("foo/name1");
  Boolean val2 = (Boolean)myEnv.lookup("foo/bar/name2");

  // The application component can also
  // lookup using full pathnames.
  Integer val3 = (Integer)initCtx.lookup("java:comp/env/name3");
  Integer val4 = (Integer)initCtx.lookup("java:comp/env/foo/name4");
  ...
}
...
<env-entry>
  <description>
     The maximum number of tax exemptions
     allowed to be set.
  </description>
  <env-entry-name>maxExemptions</env-entry-name>
  <env-entry-type>java.lang.Integer</env-entry-type>
  <env-entry-value>15</env-entry-value>
</env-entry>
<env-entry>
  <description>
     The minimum number of tax exemptions allowed to
     be set.
  </description>
  <env-entry-name>minExemptions</env-entry-name>
  <env-entry-type>java.lang.Integer</env-entry-type>
  <env-entry-value>1</env-entry-value>
</env-entry>
<env-entry>
  <env-entry-name>foo/name1</env-entry-name>
  <env-entry-type>java.lang.String</env-entry-type>
  <env-entry-value>value1</env-entry-value>
</env-entry>
<env-entry>
  <env-entry-name>foo/bar/name2</env-entry-name>
  <env-entry-type>java.lang.Boolean</env-entry-type>
  <env-entry-value>true</env-entry-value>
</env-entry>
<env-entry>
  <description>Some description.</description>
  <env-entry-name>name3</env-entry-name>
  <env-entry-type>java.lang.Integer</env-entry-type>
</env-entry>
<env-entry>
  <env-entry-name>foo/name4</env-entry-name>
  <env-entry-type>java.lang.Integer</env-entry-type>
  <env-entry-value>10</env-entry-value>
</env-entry>
<env-entry>
  <env-entry-name>helperClass</env-entry-name>
  <env-entry-type>java.lang.Class</env-entry-type>
  <env-entry-value>com.acme.helper.Helper</env-entry-value>
</env-entry>
<env-entry>
  <env-entry-name>timeUnit</env-entry-name>
  <env-entry-type>java.util.concurrent.TimeUnit</env-entry-type>
  <env-entry-value>NANOSECONDS</env-entry-value>
</env-entry>
<env-entry>
  <env-entry-name>bar</env-entry-name>
  <env-entry-type>java.lang.Integer</env-entry-type>
  <lookup-name>java:app/env/appBar</lookup-name>
</env-entry>
...
...
<env-entry>
  <description>
     The maximum number of tax exemptions
     allowed to be set.
  </description>
  <env-entry-name>
     com.example.PayrollService/maxExemptions
  </env-entry-name>
  <env-entry-type>java.lang.Integer</env-entry-type>
  <env-entry-value>15</env-entry-value>
  <injection-target>
    <injection-target-class>
       com.example.PayrollService
    </injection-target-class>
    <injection-target-name>
       maxExemptions
    </injection-target-name>
  </injection-target>
</env-entry>
<env-entry>
  <description>
     The minimum number of tax exemptions
     allowed to be set.
  </description>
  <env-entry-name>
     com.example.PayrollService/minExemptions
  </env-entry-name>
  <env-entry-type>java.lang.Integer</env-entry-type>
  <env-entry-value>1</env-entry-value>
  <injection-target>
    <injection-target-class>
       com.example.PayrollService
    </injection-target-class>
    <injection-target-name>
       minExemptions
    </injection-target-name>
  </injection-target>
</env-entry>
...
// The maximum number of tax exemptions, configured by the Deployer.
@Resource int maxExemptions = 4;        // defaults to 4
...
<env-entry>
  <env-entry-name>somePackage.SomeClass/timeout</env-entry-name>
  <env-entry-type>java.lang.Integer</env-entry-type>
  <injection-target>
    <injection-target-class>
       somePackage.SomeClass
    </injection-target-class>
    <injection-target-name>timeout</injection-target-name>
  </injection-target>
  <lookup-name>java:app/env/timeout</lookup-name>
</env-entry>
...
package com.acme.example;

@Stateless public class ExampleBean implements Example {
  ...
  @EJB private ShoppingCart myCart;
  ...
}
@EJB(
  name = "ejb/shopping-cart",
  beanName = "cart1",
  beanInterface = ShoppingCart.class,
  description = "The shopping cart for this application"
)
private ShoppingCart myCart;
@EJB(
  lookup="java:app/cartModule/ShoppingCart",
  description = "The shopping cart for this application"
)
private ShoppingCart myOtherCart;
@EJB(
  name="ejb/shopping-cart",
  beanInterface=ShoppingCartHome.class,
  beanName="cart1",
  description="The shopping cart for this application"
)
private ShoppingCartHome myCartHome;
@EJB(
  name="ejb/shopping-cart",
  beanInterface=ShoppingCartBean.class,
  beanName="cart1",
  description="The shopping cart for this application"
)
private ShoppingCartBean myCart;
public void changePhoneNumber(...) {
  ...
  // Obtain the default initial JNDI context.
  Context initCtx = new InitialContext();

  // Look up the home interface of the EmployeeRecord
  // enterprise bean in the environment.
  Object result = initCtx.lookup("java:comp/env/ejb/EmplRecord");

  // Convert the result to the proper type.
  EmployeeRecordHome emplRecordHome = (EmployeeRecordHome)
         javax.rmi.PortableRemoteObject.narrow(result,
            EmployeeRecordHome.class);
 ...
}
...
<ejb-ref>
  <description>
     This is a reference to the entity bean that
     encapsulates access to employee records.
  </description>
  <ejb-ref-name>ejb/EmplRecord</ejb-ref-name>
  <ejb-ref-type>Entity</ejb-ref-type>
  <home>com.wombat.empl.EmployeeRecordHome</home>
  <remote>com.wombat.empl.EmployeeRecord</remote>
</ejb-ref>

<ejb-ref>
  <ejb-ref-name>ejb/Payroll</ejb-ref-name>
  <ejb-ref-type>Entity</ejb-ref-type>
  <home>com.aardvark.payroll.PayrollHome</home>
  <remote>com.aardvark.payroll.Payroll</remote>
</ejb-ref>

<ejb-ref>
  <ejb-ref-name>ejb/PensionPlan</ejb-ref-name>
  <ejb-ref-type>Session</ejb-ref-type>
  <home>com.wombat.empl.PensionPlanHome</home>
  <remote>com.wombat.empl.PensionPlan</remote>
  <lookup-name>java:global/personnel/retirement/PensionPlan</lookup-name>
</ejb-ref>
...
...
<ejb-ref>
  <description>
     This is a reference to the entity bean that
     encapsulates access to employee records. It
     has been linked to the entity bean named
     EmployeeRecord in this application.
  </description>
  <ejb-ref-name>ejb/EmplRecord</ejb-ref-name>
  <ejb-ref-type>Entity</ejb-ref-type>
  <home>com.wombat.empl.EmployeeRecordHome</home>
  <remote>com.wombat.empl.EmployeeRecord</remote>
  <ejb-link>EmployeeRecord</ejb-link>
</ejb-ref>
...
...
<ejb-ref>
  <description>
     This is a reference to the entity bean that
     encapsulates access to a product. It
     has been linked to the entity bean named
     ProductEJB in the product.jar file in this
     application.
  </description>
  <ejb-ref-name>ejb/Product</ejb-ref-name>
  <ejb-ref-type>Entity</ejb-ref-type>
  <home>com.acme.products.ProductHome</home>
  <remote>com.acme.products.Product</remote>
  <ejb-link>../products/product.jar#ProductEJB</ejb-link>
</ejb-ref>
...
...
<ejb-ref>
  <ejb-ref-name>ShoppingService/myCart</ejb-ref-name>
  <ejb-link>../products/product.jar#ShoppingCart</ejb-link>
</ejb-ref>
...
...
<ejb-ref>
  <ejb-ref-name>ShoppingService/myCart</ejb-ref-name>
  <lookup-name>java:app/products/ShoppingCart</lookup-name>
</ejb-ref>
...
...
<ejb-ref>
  <ejb-ref-name>ShoppingService/myCart</ejb-ref-name>
  <lookup-name>java:global/products/ShoppingCart</lookup-name>
</ejb-ref>
...
// The employee database.
@Resource javax.sql.DataSource employeeAppDB;

public void changePhoneNumber(...) {
  ...
  // Invoke factory to obtain a resource. The security
  // principal for the resource is not given, and
  // therefore it will be configured by the Deployer.
  java.sql.Connection con = employeeAppDB.getConnection();
  ...
}
// The customer database, looked up in the application environment.
@Resource(lookup="java:app/env/customerDB")
javax.sql.DataSource customerAppDB;
@Resource(name="java:app/env/customerDB",
          type=javax.sql.DataSource.class)
public class AnApplicationClass {
  ...
}
public void changePhoneNumber(...) {
  ...
  // obtain the initial JNDI context
  Context initCtx = new InitialContext();

  // perform JNDI lookup to obtain resource manager
  // connection factory
  javax.sql.DataSource ds = (javax.sql.DataSource)
     initCtx.lookup("java:comp/env/jdbc/EmployeeAppDB");

  // Invoke factory to obtain a resource. The security
  // principal for the resource is not given, and
  // therefore it will be configured by the Deployer.
  java.sql.Connection con = ds.getConnection();
  ...
}
...
<resource-ref>
  <description>
     A data source for the database in which
     the EmployeeService enterprise bean will
     record a log of all transactions.
  </description>
  <res-ref-name>jdbc/EmployeeAppDB</res-ref-name>
  <res-type>javax.sql.DataSource</res-type>
  <res-auth>Container</res-auth>
  <res-sharing-scope>Shareable</res-sharing-scope>
</resource-ref>
...
...
<resource-ref>
  <res-ref-name>jdbc/EmployeeAppDB</res-ref-name>
  <res-type>javax.sql.DataSource</res-type>
  <res-auth>Container</res-auth>
  <res-sharing-scope>Shareable</res-sharing-scope>
  <lookup-name>java:app/env/TheEmployeeDB</lookup-name>
</resource-ref>
...
@Resource jakarta.jms.Queue stockQueue;
@Resource(lookup="java:app/env/TheOrderQueue")
jakarta.jms.Queue orderQueue;
// Obtain the default initial JNDI context.
Context initCtx = new InitialContext();

// Look up the Jakarta Messaging StockQueue in the environment.
Object result = initCtx.lookup("java:comp/env/jms/StockQueue");

// Convert the result to the proper type.
jakarta.jms.Queue queue = (jakarta.jms.Queue)result;
...
<message-destination-ref>
  <description>
     This is a reference to a Jakarta Messaging queue used in the
     processing of Stock info
  </description>
  <message-destination-ref-name>
     jms/StockInfo
  </message-destination-ref-name>
  <message-destination-type>
     jakarta.jms.Queue
  </message-destination-type>
  <message-destination-usage>
     Produces
  </message-destination-usage>
</message-destination-ref>
...
@Resource UserTransaction tx;
public void updateData(...) {
  ...
  // Start a transaction.
  tx.begin();
  ...
  // Perform transactional operations on data.
  ...
  // Commit the transaction.
  tx.commit();
  ...
}
public void updateData(...) {
  ...
  // Obtain the default initial JNDI context.
  Context initCtx = new InitialContext();

  // Look up the UserTransaction object.
  UserTransaction tx = (UserTransaction)initCtx.lookup(
                                 "java:comp/UserTransaction");

  // Start a transaction.
  tx.begin();
  ...
  // Perform transactional operations on data.
  ...
  // Commit the transaction.
  tx.commit();
  ...
}
@Resource ORB orb;
public void method(...) {
  ...
  // Get the POA to use when creating object references.
  POA rootPOA = (POA)orb.resolve_initial_references("RootPOA");
  ...
}
public void method(...) {
  ...
  // Obtain the default initial JNDI context.
  Context initCtx = new InitialContext();
  // Look up the ORB object.
  ORB orb = (ORB)initCtx.lookup("java:comp/ORB");
  // Get the POA to use when creating object references.
  POA rootPOA = (POA)orb.resolve_initial_references("RootPOA");
  ...
}
@PersistenceUnit
EntityManagerFactory emf;

@PersistenceUnit(unitName="InventoryManagement")
EntityManagerFactory inventoryEMF;
@PersistenceUnit(name="persistence/InventoryAppDB")
@Stateless
public class InventoryManagerBean implements InventoryManager {
  EJBContext ejbContext;
  ...
  public void updateInventory(...) {
    ...
    // obtain the initial JNDI context
    Context initCtx = new InitialContext();

    // perform JNDI lookup to obtain entity manager factory
    EntityManagerFactory = (EntityManagerFactory)
       initCtx.lookup(
          "java:comp/env/persistence/InventoryAppDB");

    // use factory to obtain application-managed entity manager
    EntityManager em = emf.createEntityManager();
    ...
  }
}
...
  <persistence-unit-ref>
    <description>
       Persistence unit for the inventory management
       application.
    </description>
    <persistence-unit-ref-name>
       persistence/InventoryAppDB
    </persistence-unit-ref-name>
    <persistence-unit-name>
       InventoryManagement
    </persistence-unit-name>
  </persistence-unit-ref>
...
...
  <persistence-unit-ref>
    <description>
       Persistence unit for the inventory management
       application.
    </description>
    <persistence-unit-ref-name>
       persistence/InventoryAppDB
    </persistence-unit-ref-name>
    <persistence-unit-name>
       ../lib/inventory.jar#InventoryManagement
    </persistence-unit-name>
  </persistence-unit-ref>
...
@PersistenceContext(type=EXTENDED)
EntityManager em;
@PersistenceContext(name="persistence/InventoryAppMgr")
@Stateless
public class InventoryManagerBean implements InventoryManager {

  public void updateInventory(...) {
    ...

    // obtain the initial JNDI context
    Context initCtx = new InitialContext();

    // JNDI lookup to obtain container-managed entity manager
    EntityManager = (EntityManager)
       initCtx.lookup(
          "java:comp/env/persistence/InventoryAppMgr");
    ...
  }
}
...
  <persistence-context-ref>
    <description>
       Persistence context for the inventory management
       application.
    </description>
    <persistence-context-ref-name>
       persistence/InventoryAppDB
    </persistence-context-ref-name>
    <persistence-unit-name>
       InventoryManagement
    </persistence-unit-name>
  </persistence-context-ref>
...
...
  <persistence-context-ref>
    <description>
       Persistence context for the inventory management
       application.
    </description>
    <persistence-context-ref-name>
       persistence/InventoryAppDB
    </persistence-context-ref-name>
    <persistence-unit-name>
       ../lib/inventory.jar#InventoryManagement
    </persistence-unit-name>
  </persistence-context-ref>
...
@Resource ValidatorFactory validatorFactory;

@Resource Validator validator;
// obtaining a Validator directly
Context initCtx = new InitialContext();
Validator validator = (Validator)initCtx.lookup(
                            "java:comp/Validator");

// obtaining a Validator from a ValidatorFactory
Context initCtx = new InitialContext();
Validator validator =
       ((ValidatorFactory) initCtx.lookup(
                             "java:comp/ValidatorFactory"))
       .getValidator();
...
<data-source>
  <description>Sample DataSource definition</description>
  <name>java:app/MyDataSource</name>
  <class-name>com.example.MyDataSource</class-name>
  <server-name>myserver.com</server-name>
  <port-number>6689</port-number>
  <database-name>myDatabase</database-name>
  <user>lance</user>
  <password>secret</password>
  <property>
    <name>Property1</name>
    <value>10</value>
  </property>
  <property>
    <name>Property2</name>
    <value>20</value>
  </property>
  <login-timeout>0</login-timeout>
  <transactional>false</transactional>
  <isolation-level>TRANSACTION_READ_COMMITTED</isolation-level>
  <initial-pool-size>0</initial-pool-size>
  <max-pool-size>30</max-pool-size>
  <min-pool-size>20</min-pool-size>
  <max-idle-time>0</max-idle-time>
  <max-statements>50</max-statements>
</data-source>
...
  @DataSourceDefinition(
     name="java:app/MyDataSource",
     className="com.example.MyDataSource",
     portNumber=6689,
     serverName="myserver.com",
     user="lance",
     password="secret")
  @Stateless
  public class MySessionBean {
    @Resource(lookup = "java:app/MyDataSource")
    DataSource myDB;
    ...
  }
...
<jms-connection-factory>
  <description>
     Sample Jakarta Messaging ConnectionFactory definition
  </description>
  <name>java:app/MyJMSCF</name>
  <interface-name>
     jakarta.jms.QueueConnectionFactory
  </interface-name>
  <resource-adapter>myJMSRA</resource-adapter>
  <user>scott</user>
  <password>secret</password>
  <client-id>MyId</client-id>
  <property>
    <name>Property1</name>
    <value>10</value>
   </property>
   <property>
     <name>Property2</name>
     <value>20</value>
   </property>
   <transactional>false</transactional>
   <max-pool-size>30</max-pool-size>
   <min-pool-size>20</min-pool-size>
</jms-connection-factory>
...
  @JMSConnectionFactoryDefinition(
     name="java:app/MyJMSCF",
     interfaceName="jakarta.jms.QueueConnectionFactory",
     resourceAdapter="myJMSRA")
  @Stateless_
  public class MySessionBean {
    @Resource(lookup = "java:app/MyJMSCF")
    ConnectionFactory myCF;
    ...
  }
...
<jms-destination>
  <description>Sample Jakarta Messaging Destination definition</description>
  <name>java:app/MyJMSDestination</name>
  <interface-name>jakarta.jms.Queue</interface-name>
  <resource-adapter>myJMSRA</resource-adapter>
  <destination-name>myQueue1</destination-name>
  <property>
    <name>Property1</name>
    <value>10</value>
  </property>
  <property>
    <name>Property2</name>
    <value>20</value>
  </property>
</jms-destination>
...
  @JMSDestinationDefinition(
     name="java:app/MyJMSQueue",
     interfaceName="jakarta.jms.Queue",
     destinationName="myQueue1")
  @Stateless
  public class MySessionBean {
    @Resource(lookup = "java:app/MyJMSQueue")
    Queue myQueue;
    ...
  }
...
<mail-session>
  <description>Sample Mail Session definition</description>
  <name>java:app/mail/MySession</name>
  <store-protocol>imap</store-protocol>
  <transport-protocol>smtp</transport-protocol>
  <host>somewhere.myco.com</host>
  <user>linda</user>
  <password>secret</password>
  <from>some.body@myco.com</from>
  <property>
    <name>mail.smtp.starttls.enable</name>
    <value>true</value>
  </property>
  <property>
    <name>mail.imap.connectiontimeout</name>
    <value>500</value>
  </property>
</mail-session>
...
  @MailSessionDefinition(_
       name="java:app/mail/MySession",
       host="somewhere.myco.com",
       from="some.body@myco.com")
  @Stateless
  public class MySessionBean {
    @Resource(lookup = "java:app/mail/MySession")
    Session myMailSession;
    ...
  }
...
<connection-factory>
  <description>Sample Connector resource definition</description>
  <name>java:app/myConnectionFactory</name>
  <interface-name>
     com.eis.ConnectionFactory
   </interface-name>
   <resource-adapter>MyEISRA</resource-adapter>
   <max-pool-size>20</max-pool-size>
   <min-pool-size>10</min-pool-size>
   <transaction-support>XATransaction</transaction-support>
   <property>
     <name>Property1</name>
     <value>prop1val</value>
   </property>
   <property>
     <name>Property2</name>
     <value>prop2val</value>
   </property>
</connection-factory>
...
  @ConnectionFactoryDefinition(
       name="java:app/myConnectionFactory",
       interfaceName="com.eis.ConnectionFactory",
       resourceAdapter="MyESRA")
  @Stateless
  public class MySessionBean {
    @Resource(lookup = "java:app/myConnectionFactory")
    ConnectionFactory myCF;
    ...
  }
...
<administered-object>
  <description>Sample Admin Object definition</description>
  <name>java:app/MyAdminObject</name>
  <class-name>com.extraServices.AdminObject</class-name>
  <resource-adapter>myESRA</resource-adapter>
  <property>
    <name>Property1</name>
    <value>10</value>
  </property>
  <property>
    <name>Property2</name>
    <value>20</value>
  </property>
</administered-object>
...
@AdministeredObjectDefinition(
    name="java:app/myAdminObject",
    className="com.extraServices.AdminObject",
    resourceAdapter="myESRA")
  @Stateless public class MySessionBean {
    @Resource(lookup="java:app/myAdminObject")
    AdminObject myAdminObject;
    ...
  }
...
<context-service>
  <name>java:app/concurrent/MyContext</name>
  <cleared>Transaction</cleared>
  <propagated>Application</propagated>
  <propagated>Security</propagated>
  <unchanged>Remaining</unchanged>
</context-service>

<managed-executor>
  <name>java:app/concurrent/MaxAsync5</name>
  <context-service-ref>java:app/concurrent/MyContext</context-service-ref>
  <max-async>5</max-async>
</managed-executor>
...
  @ContextServiceDefinition(
     name = "java:app/concurrent/AppContextOnly",
     cleared = { TRANSACTION, SECURITY },
     propagated = APPLICATION,
     unchanged = ALL_REMAINING)

  @ManagedExecutorDefinition(
     name = "java:app/concurrent/MaxAsync10",
     context = "java:app/concurrent/AppContextOnly",
     qualifiers = MaxAsync10.class,
     maxAsync = 10)
  @Stateless
  public class MySessionBean {
    @Resource(lookup = "java:app/concurrent/MaxAsync10")
    ManagedExecutorService maxAsync10Executor;
    ...
  }
  @ApplicationScoped
  public class MyBean {
    @Inject
    @MaxAsync10
    ManagedExecutorService maxAsync10Executor;
    ...
  }
@Resource(lookup="java:comp/DefaultDataSource")
DataSource myDS;
@Resource
DataSource myDS;
@Resource(name="myJMSCF",
          lookup="java:comp/DefaultJMSConnectionFactory")
ConnectionFactory myJMScf;
@Resource(name="myJMSCF")
ConnectionFactory myJMScf;
@Resource(name="myManagedExecutorService",
          lookup="java:comp/DefaultManagedExecutorService")
ManagedExecutorService myManagedExecutorService;
@Resource(name="myManagedExecutorService")
ManagedExecutorService myManagedExecutorService;
java:app/<module-name>/<bean-name>

java:module/<bean-name>
@Resource ShoppingCartBean cart;

@Resource(lookup="java:module/cart") ShoppingCart cart;

ShoppingCart cart = (ShoppingCart) context.lookup("java:module/cart");
...
<resource-ref>
  <res-ref-name>bean/cart</ref-ref-name>
  <ref-type>com.acme.ShoppingCart</ref-type>
  <lookup-name>java:module/cart</lookup-name>
</resource-ref>
...
@Resource BeanManager manager;
@Inject BeanManager manager;
myapp.ear
 inventory.jar
 ui.war
bigapp.ear
 ejbs
   inventory.jar
   accounts.jar
 ui
   store.war
   admin.war
public ClassLoader getContextClassLoader() {
  return AccessController.doPrivileged(
    new PrivilegedAction<ClassLoader>() {
      public ClassLoader run() {
        ClassLoader cl = null;
        try {
          cl = Thread.currentThread().
                        getContextClassLoader();
        } catch (SecurityException ex) { }
        return cl;
      }
    });
}
ClassLoader cl = getContextClassLoader();
if (cl != null) {
  try {
    clazz = Class.forName(name, false, cl);
  } catch (ClassNotFoundException ex) {
    clazz = Class.forName(name);
  }
 } else
  clazz = Class.forName(name);
app1.ear:
 META-INF/application.xml
 ejb1.jar      Class-Path: util.jar
 ejb2.jar      Class-Path: util.jar
 util.jar
app2.ear:
  META-INF/application.xml
  ejb1.jar      Class-Path: ejb1_client.jar
    deployment descriptor contains:
        <ejb-client-jar>ejb1_client.jar</ejb-client-jar>
  ejb1_client.jar
  ejb2.jar      Class-Path: ejb1_client.jar

app3.ear:
  META-INF/application.xml
  ejb1_client.jar
  ejb3.jar      Class-Path: ejb1_client.jar
  webapp.war    Class-Path: ejb1_client.jar
     WEB-INF/web.xml
     WEB-INF/lib/jakartaservlet1.jar
app1.ear:
  META-INF/application.xml
  ejb1.jar :
    META-INF/MANIFEST.MF:
      Extension-List: util
      util-Extension-Name: com/example/util
      util-Specification-Version: 1.4
    META-INF/ejb-jar.xml

util.jar:
  META-INF/MANIFEST.MF:
  Extension-Name: com/example/util
  Specification-Title: example.com’s util package
  Specification-Version: 1.4
  Specification-Vendor: example.com
  Implementation-Version: build96
@Stateful
public class BookShopBean
        extends Business
        implements BookShop, Auditable {
    ...
}
<h:outputText value="#{products.total}"/>
@Singleton
class Shop { .. }
@Stateless
class PaymentProcessorImpl implements PaymentProcessor { ... }
@ConversationScoped @Stateful @Default @Model
public class ShoppingCart { ... }
@Stateless
@Named("loginAction")
public class LoginActionImpl implements LoginAction { ... }
@Stateless
@Mock
@Named("loginAction")
public class MockLoginActionImpl extends LoginActionImpl { ... }
@Stateless
public class LoginActionBean implements LoginAction { ... }
@Stateless @Mock @Specializes
public class MockLoginActionBean extends LoginActionBean implements LoginAction { ... }
@Inject @CustomerDatabase Datasource customerData;
@Inject @CustomerDatabase EntityManager customerDatabaseEntityManager;
@Inject @CustomerDatabase EntityManagerFactory customerDatabaseEntityManagerFactory;
@Inject PaymentService remotePaymentService;
@Produces @WebServiceRef(lookup="java:app/service/PaymentService")
PaymentService paymentService;
@Produces @EJB(ejbLink="../their.jar#PaymentService")
PaymentService paymentService;
@Produces @Resource(lookup="java:global/env/jdbc/CustomerDatasource")
@CustomerDatabase Datasource customerDatabase;
@Produces @PersistenceContext(unitName="CustomerDatabase")
@CustomerDatabase EntityManager customerDatabasePersistenceContext;
@Produces @PersistenceUnit(unitName="CustomerDatabase")
@CustomerDatabase EntityManagerFactory customerDatabasePersistenceUnit;
<T extends Servlet> void decorateServlet(@Observes ProcessInjectionTarget<T> pit) {
    pit.setInjectionTarget( decorate( pit.getInjectionTarget() ) );
}
public interface ProcessSessionBean<X>
        extends ProcessManagedBean<Object> {
    public String getEjbName();
    public SessionBeanType getSessionBeanType();
}
public enum SessionBeanType { STATELESS, STATEFUL, SINGLETON }
public ELResolver getELResolver();
public ExpressionFactory wrapExpressionFactory(ExpressionFactory expressionFactory);
 <!DOCTYPE application PUBLIC "-//Sun
Microsystems, Inc.//DTD J2EE Application 1.3//EN"
"http://java.sun.com/dtd/application_1_3.dtd">

Spec	Classes supporting injection	Support level
Servlet	servlets servlet filters event listeners HTTP upgrade handlers	Standard Standard Standard Standard
Jakarta Server Pages	tag handlers tag library event listeners	Standard Standard
Jakarta Server Faces	managed classes ^[6]	Standard
Jakarta Web Services	service endpoints handlers	Standard Standard
Jakarta RESTful Web Services	Jakarta RESTful Web Services components ^[7]	Standard
WebSocket	endpoints	Standard
Jakarta Enterprise Beans	beans	Standard
Interceptor	interceptors ^[8]	Standard
Jakarta Persistence	attribute converters entity listeners	Standard Standard
Managed Beans	managed beans	Standard
CDI ^[9]	CDI-style managed beans ^[10] decorators ^[11]	Standard Standard
Jakarta EE platform	main class (static) login callback handler	Limited Standard

Jakarta EE Technology	App Client	Web	Enterprise Beans	Activation
Y	Y	Y	Authorization	N
Y	Y	Authentication	N	Y
Y	Batch	N	Y	Y
Validation	Y	Y	Y	Annotations
Y	Y	Y	Concurrency	N
Y	Y	Connectors	N	Y
Y	Contexts and Dependency Injection	Y	Y	Y
Dependency Injection	Y	Y	Y	Debugging Support for Other Languages
N	Y	N	Expression Language	N
Y	N	Interceptors	Y	Y
Y	JSON Processing	Y	Y	Y
JSON Binding	Y	Y	Y	Mail
Y	Y	Y	Managed Beans (Deprecated)	Y
Y	Y	Messaging	Y	Y
Y	Persistence	Y	Y	Y
RESTful Web Services	N	Y	N	Security
N	Y	Y	Servlet	N
Y	N	Server Faces	N	Y
N	Server Pages	N	Y	N
Standard Tag Library	N	Y	N	Transactions
N	Y	Y	WebSocket	N

Jakarta EE Technology	Status
SOAP with Attachments	Removed in Jakarta EE 11
XML Binding	Removed in Jakarta EE 11
XML Web Services	Removed in Jakarta EE 11
Embeddable EJB Container (Jakarta Enterprise Beans, Core Features 4.0, Chapter 17)	Removed in Jakarta EE 10
Entity Beans, both Container and Bean Managed Persistence (Jakarta Enterprise Beans 4.0, Optional Features, Chapters 3 - 7)	Removed in Jakarta EE 10
Embeddable EJB Container (Jakarta Enterprise Beans, Core Features 4.0, Chapter 17)	Removed in Jakarta EE 10

MIME Type	Java Type
image/gif	java.awt.Image
image/jpeg	java.awt.Image
image/png	java.awt.Image

Mime Type	Java Type
text/plain	java.lang.String
text/html_	java.lang.String
text/xml	java.lang.String
multipart/*	jakarta.mail.internet.MimeMultipart
message/rfc822	jakarta.mail.internet.MimeMessage

Annotation	App Client	Web	Enterprise Beans
Resource	Y	Y	Y
Resources	Y	Y	Y
PostConstruct	Y	Y	Y
PreDestroy	Y	Y	Y
Generated	N	N	N
RunAs	N	Y	Y
DeclareRoles	N	Y	Y
RolesAllowed	N	Y	Y
PermitAll	N	Y	Y
DenyAll	N	Y	Y
DataSourceDefinition	Y	Y	Y
DataSourceDefinitions	Y	Y	Y
Priority	Y	Y	Y

Deployment descriptor	metadata-complete?	process annotations?
application-client_1_2	N/A	No
application-client_1_3	N/A	No
application-client_1_4	N/A	No
application-client_5	Yes	No
application-client_5	No	Yes
application-client_6	Yes	No
application-client_6	No	Yes
application-client_7	Yes	No
application-client_7	No	Yes
application-client_8	Yes	No
application-client_8	No	Yes
application-client_9	Yes	No
application-client_9	No	Yes
none	N/A	Yes

Java EE 8 Specification	Jakarta EE 8 Specification
Java™ Platform, Enterprise Edition 8	Jakarta™ EE Platform 8
Enterprise JavaBeans™ 3.2	Jakarta™ Enterprise Beans 3.2
Common Annotations for the Java Platform 1.3	Jakarta™ Annotations 1.3
Java™ Servlet 4.0	Jakarta™ Servlet 4.0
Java API for WebSocket 1.1	Jakarta™ WebSocket 1.1
JavaServer Faces 2.3	Jakarta™ Server Faces 2.3
JavaServer Pages™ 2.3	Jakarta™ Server Pages 2.3
Standard Tag Library for JavaServer Pages 1.2	Jakarta™ Standard Tag Library 1.2
Expression Language 3.0	Jakarta™ Expression Language 3.0
Debugging Support for Other Languages 1.0	Jakarta™ Debugging Support for Other Languages 1.0
Java™ Message Service 2.0	Jakarta™ Messaging 2.0
Java™ Transaction API 1.2	Jakarta™ Transaction 1.3
JavaMail™ API 1.6	Jakarta™ Mail 1.6
Java EE™ Connector Architecture 1.7	Jakarta™ Connectors 1.7
Web Services for Java EE 1.4	Jakarta™ Enterprise Web Services 1.4
Java™ API for XML-based RPC 1.1	Jakarta™ XML RPC 1.1
Java™ API for XML Registries 1.0	Jakarta™ XML Registries 1.0
Java™ API for RESTful Web Services 2.1	Jakarta™ RESTful Web Services 2.1
Java API for JSON Processing 1.1	Jakarta™ JSON Processing 1.1
Java API for JSON Binding 1.0	Jakarta™ JSON Binding 1.0
Java™ Platform, Enterprise Edition Management 1.1	Jakarta™ Management 1.1
Java™ Platform, Enterprise Edition Deployment 1.2	Jakarta™ Deployment 1.7
Java™ Authorization Service Provider Contract for Containers 1.5	Jakarta™ Authorization 1.5
Java™ Authentication Service Provider Interface for Containers 1.1	Jakarta™ Authentication 1.1
Java™ EE Security API 1.0	Jakarta™ Security 1.0
Java Persistence 2.2	Jakarta™ Persistence 2.2
Bean Validation 2.0	Jakarta™ Bean Validation 2.0
Managed Beans 1.0	Jakarta™ Managed Beans 1.0
Interceptors 1.2 rev A	Jakarta™ Interceptors 1.2
Contexts and Dependency Injection for the Java EE Platform 2.0	Jakarta™ Contexts and Dependency Injection 2.0
Dependency Injection for Java 1.0	Jakarta™ Dependency Injection 1.0
Concurrency Utilities for Java EE 1.0	Jakarta™ Concurrency 1.1
Batch Applications for the Java Platform 1.0 rev A	Jakarta™ Batch 1.0

Java EE 8 Specification	Jakarta EE Specification (future)
JavaBeans™ Activation Framework 1.1	Jakarta Activation 1.2
Java™ Architecture for XML Binding 2.3	Jakarta XML Binding 2.3
Java™ API for XML Web Services 2.3	Jakarta XML Web Services 2.3
SOAP with Attachments API for Java™ 1.3	Jakarta SOAP with Attachments 1.4
Web Services Metadata for the Java Platform 2.1	Jakarta Web Services Metadata 2.1

Jakarta EE Platform

Copyright

Eclipse Foundation Specification License

Disclaimers

1. Introduction

1.1. Acknowledgements for the Initial Version of Java EE

1.2. Acknowledgements for Java EE Version 1.3

1.3. Acknowledgements for Java EE Version 1.4

1.4. Acknowledgements for Java EE Version 5

1.5. Acknowledgements for Java EE Version 6

1.6. Acknowledgements for Java EE Version 7

1.7. Acknowledgements for Java EE Version 8

1.8. Acknowledgements for Jakarta EE 8

1.9. Acknowledgements for Jakarta EE 9

1.10. Acknowledgements for Jakarta EE 9.1

1.11. Acknowledgements for Jakarta EE 10.0

1.12. Acknowledgements for Jakarta EE 11.0

2. Platform Overview

2.1. Architecture

2.2. Profiles

2.3. Application Components

2.3.1. Jakarta EE Server Support for Application Components

2.4. Containers

2.4.1. Container Requirements

2.4.2. Jakarta EE Servers

2.5. Resource Adapters

2.6. Database

2.7. Jakarta EE Standard Services

2.7.1. HTTP

2.7.2. HTTPS

2.7.3. Jakarta Transaction API (JTA)

2.7.4. JDBC™ API

2.7.5. Jakarta Persistence API

2.7.6. Jakarta™ Messaging

2.7.7. Java Naming and Directory Interface™ (JNDI)

2.7.8. Jakarta™ Mail

2.7.9. Jakarta Activation Framework (JAF)

2.7.10. XML Processing

2.7.11. Jakarta Connectors

2.7.12. Security Services

2.7.13. XML Web Services

2.7.14. Jakarta JSON Processing

2.7.15. Jakarta JSON Binding

2.7.16. Jakarta WebSocket

2.7.17. Jakarta RESTful Web Services

2.7.18. Jakarta Concurrency

2.7.19. Jakarta Batch

2.7.20. Jakarta Enterprise Beans

2.8. Interoperability

2.9. Flexibility of Product Requirements

2.10. Jakarta EE Product Packaging

2.11. Jakarta EE Product Extensions

2.12. Platform Roles

2.12.1. Jakarta EE Product Provider

2.12.2. Application Component Provider

2.12.3. Application Assembler

2.12.4. Deployer

2.12.5. System Administrator

2.12.6. Tool Provider

2.12.7. System Component Provider

2.13. Platform Contracts

2.13.1. Jakarta EE APIs

2.13.2. Jakarta EE Service Provider Interfaces (SPIs)

2.13.3. Network Protocols

2.13.4. Deployment Descriptors and Annotations

2.14. Changes in J2EE 1.3

2.15. Changes in J2EE 1.4

2.16. Changes in Java EE 5

2.17. Changes in Java EE 6

2.18. Changes in Java EE 7

2.19. Changes in Java EE 8

2.20. Changes in Jakarta EE 8

2.21. Changes in Jakarta EE 9

2.22. Changes in Jakarta EE 9.1

2.23. Changes in Jakarta EE 10

2.24. Changes in Jakarta EE 11

3. Security

3.1. Introduction

3.2. A Simple Example

3.3. Security Architecture