Jakarta EE Platform

Highly available

Specification: Jakarta EE Platform

Version: 8

Status: Final Release

Release: August 26, 2019
// 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 javax.jms.Queue stockQueue;
@Resource(lookup="java:app/env/TheOrderQueue")
javax.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.
javax.jms.Queue queue = (javax.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>
     javax.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>
     javax.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="javax.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>javax.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="javax.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;
    ...
  }
@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;
permission <class> [<name> [, <action list>]];
...
<permissions>
  <permission>
    <class-name>java.io.FilePermission</class-name>
    <name>/tmp/abc</name>
    <actions>read,write</actions>
  </permission>
  <permission>
    <class-name>java.lang.RuntimePermission</class-name>
    <name>createClassLoader</name>
  </permission>
</permissions>
...
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
 <!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
JAX-WS	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
Java Persistence	entity listeners	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

Java Technology	App Client	Web	Enterprise Beans	Status
Enterprise Beans 3.2	Y ^[14]	Y	Y	REQ, OPT ^[15], POPT ^[16]
Servlet 4.0	N	Y	N	REQ
Server Pages 2.3	N	Y	N	REQ
Expression Language 3.0	N	Y	N	REQ
Messaging 2.0	Y	Y	Y	REQ
Transactions 1.3	N	Y	Y	REQ
Mail 1.6	Y	Y	Y	REQ
Connector 1.7	N	Y	Y	REQ
Enterprise Web Services 1.4	Y	Y	Y	REQ
XML RPC 1.1	Y	Y	Y	OPT
RESTful Web Services 2.1	N	Y	N	REQ
WebSocket 1.1	N	Y	N	REQ
JSON Processing 1.1	Y	Y	Y	REQ
JSON Binding 1.0	Y	Y	Y	REQ
Concurrency 1.1	N	Y	Y	REQ
Batch 1.0	N	Y	Y	REQ
XML Registries 1.0	Y	Y	Y	OPT
Management 1.1	Y	Y	Y	REQ
Deployment 1.7 ^[17]	N	N	N	OPT
Authorization 1.5	N	Y	Y	REQ
Authentication 1.1	N	Y	Y	REQ
Security API 1.0	N	Y	Y	REQ
Server Pages Debugging 1.0	N	Y	N	REQ
Standard Tag Library 1.2	N	Y	N	REQ
Server Faces 2.3	N	Y	N	REQ
Common Annotations 1.3	Y	Y	Y	REQ
Persistence 2.2	Y	Y	Y	REQ
Bean Validation 2.0	Y	Y	Y	REQ
Managed Beans 1.0	Y	Y	Y	REQ
Interceptors 1.2	Y	Y	Y	REQ
Contexts and Dependency Injection 2.0	Y	Y	Y	REQ
Dependency Injection 1.0	Y	Y	Y	REQ

Security Permissions	Target	Action
Application Clients
java.awt.AWTPermission	accessClipboard
java.awt.AWTPermission	accessEventQueue
java.awt.AWTPermission	showWindowWithout WarningBanner
java.lang.RuntimePermission	exitVM
java.lang.RuntimePermission	loadLibrary.*
java.lang.RuntimePermission	queuePrintJob
java.net.SocketPermission	*	connect
java.net.SocketPermission	localhost:1024-	accept,listen
java.io.FilePermission	*	read,write
java.util.PropertyPermission	*	read
Applet Clients
java.net.SocketPermission	codebase	connect
java.util.PropertyPermission	limited	read
Web, Enterprise Beans, and Resource Adapter Components
java.lang.RuntimePermission	loadLibrary.*
java.lang.RuntimePermission	queuePrintJob
java.net.SocketPermission	*	connect
java.io.FilePermission	*	read,write ^[19]
java.io.FilePermission	file:${javax.servlet.context.tempdir}	read, write ^[20]
java.util.PropertyPermission	*	read

Security Permissions	Target	Action
Web, Enterprise Beans, and Resource Adapter Components
java.security.AllPermission
java.security.SecurityPermission
java.security.UnresolvedPermission
java.awt.AWTPermission
java.io.SerializablePermission
java.lang.reflect.ReflectPermission
java.lang.RuntimePermission	<any except loadLibrary.* and queuePrintJob> ^[21]
java.net.NetPermission
java.sql.SQLPermission
java.util.PropertyPermission	<any>	write ^[22]
java.util.logging.LoggingPermission
javax.net.ssl.SSLPermission
java.security.auth.AuthPermission
java.security.auth.PrivateCredentialPermission
java.security.auth.kerberos.DelegationPermission
java.security.auth.kerberos.ServicePermission
javax.sound.sampled.AudioPermission

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/*	javax.mail.internet.MimeMultipart
message/rfc822	javax.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
ManagedBean	Y	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
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

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. RMI-IIOP (Proposed Optional)

2.7.5. Java IDL (Proposed Optional)

2.7.6. JDBC™ API

2.7.7. Jakarta Persistence API

2.7.8. Jakarta™ Messaging

2.7.9. Java Naming and Directory Interface™ (JNDI)

2.7.10. Jakarta™ Mail

2.7.11. JavaBeans™ Activation Framework (JAF)

2.7.12. XML Processing

2.7.13. Jakarta Connector Architecture

2.7.14. Security Services

2.7.15. Web Services

2.7.16. Jakarta Concurrency

2.7.17. Jakarta Batch

2.7.18. Jakarta Management

2.7.19. Jakarta Deployment

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

3. Security

3.1. Introduction

3.2. A Simple Example

3.3. Security Architecture

3.3.1. Goals

3.3.2. Non Goals

3.3.3. Terminology

3.3.4. Container Based Security

3.3.4.1. Declarative Security

3.3.4.2. Programmatic Security

3.3.5. Distributed Security

3.3.6. Authorization Model

3.3.6.1. Role Mapping