JEE

Introduction

Versions

• J2EE
• JEE 5
• JEE 6

Die aktuelle Version der J2EE-Spezifikation ist die Version 6.0. Der neue Name für die Spezifikation lautet Java Platform, Enterprise Edition, kurz Java EE.

Overview

JEE basiert auf der Standard Edition (Java SE) and is a collection of specifications for server-based services and frameworks. The Java EE platform uses a simplified programming model. XML deployment descriptors are optional. Instead, a developer can simply enter the information as an annotation directly into a Java source file, and the Java EE server will configure the component at deployment and runtime. These annotations are generally used to embed in a program data that would otherwise be furnished in a deployment descriptor. With annotations, you put the specification information in your code next to the program element affected.

In the Java EE platform, dependency injection can be applied to all resources that a component needs, effectively hiding the creation and lookup of resources from application code. Dependency injection can be used in EJB containers, web containers, and application clients. Dependency injection allows the Java EE container to automatically insert references to other required components or resources, using annotations.

Expert groups, composed of interested parties, have created Java Specification Requests (JSRs) to define the various Java EE technologies:

• Web Services Technologies
  • Implementing Enterprise Web Services (JSR 109)
  • Java API for XML-Based Web Services (JAX-WS) 2.0 (JSR 224)
  • Java API for XML-Based RPC (JAX-RPC) 1.1 (JSR 101)
  • Java Architecture for XML Binding (JAXB) 2.0 (JSR 222)
  • SOAP with Attachments API for Java (SAAJ) (JSR 67)
  • Streaming API for XML (JSR 173)
  • Web Service Metadata for the Java Platform (JSR 181)
• Web Application Technologies
  • Java Servlet (JSR 154)
  • Java Server Faces 1.2 (JSR 252)
  • Java Server Pages
  • Java Server Pages Standard Tag Library (JSR 52)
• Enterprise Application Technologies
  • Enterprise Java Beans 3.0 (JSR 220)
  • J2EE Connector Architecture 1.5 (JCA) (JSR 112)
  • Common Annotations for the Java Platform (JSR 250)
  • Java Message Service (JMS) (JSR 914)
  • Java Persistence API (JSR 220)
  • Java Transaction API (JTA) (JSR 907)
  • Java Beans Activation Framework (JAF) 1.1 (JSR 925)
  • Java Mail (JSR 919)
  • Contexts and Dependency Injection (CDI) (JSR 299)
• Management and Security Technologies
  • J2EE Application Deployment (JSR 88)
  • J2EE Management (JSR 77)
  • Java Authentication and Authorization Services (JAAS) (JSR 115)
  • Java Naming and Directory Interface (JNDI)

Successfully tested JEE-server get from Sun the grade 'Jave EE compliant'.

Web-Applications

A web application is a collection of servlets, jsps, html-pages, classes and other resources installed under a specific subset of the server's URL namespace such as /catalog and possibly installed via a .war file. In the case of a web application marked "distributed" in its deployment descriptor, there will be one context instance for each virtual machine.

Deployment Descriptor

Eine Web-Applikation wird im File web.xml beschrieben. Since JEE6 it is optional. Das root Element ist <web-app>. When the web server receives a request, it determines which servlet class to call using web.xml, which resides in the war/WEB-INF/ directory in the WAR. WEB-INF/ and web.xml are part of the servlet specification. The entries are:

<filter>,<filter-mapping>

Servlet-Filter bieten eine Möglichkeit, auf die Werte des Requests und der Response um eine Anfrage an eine Web-Ressource herum zuzugreifen. Dabei können mehrere Filter je nach Konfiguration eine Filterkette bilden, die der Request durchläuft. Dabei wird mittels Mapping-Regeln bestimmt, welche Filter für welche Requests zuständig sind und ggf. eine Kette bilden.

Jeder Filter muss das Interface javax.servlet.Filter implementieren.

<filter>
  <filter-name><Name></filter-name>
  <filter-class><Full classname></filter-class>
  <init-param>
     <param-name><Parametername></param-name>
     <param-value><Parametervalue</param-value>
  </init-param>
</filter>

<filter-mapping>
  <filter-name><Name s. above></filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

<listener>

<listener> braces the listener classes. <listener-class> contains the name of the class that responds to a Web Application event, e.g. to listen for application create/destroy events, to listen for session create/destroy events, to listen for changes to session attributes. The named classes have to implement specific interfaces:

• ServletContextListener
• HttpSessionListener
• HttpSessionAttributeListener

<servlet>

Ein Servlet wird mit den folgenden Elementen beschrieben:

<servlet-name>	required
<servlet-class>	required (or use <jsp-file>)	[<Packages>].<Class>

Zur Abbildung auf eine URL dient das <servlet-mapping> mit den folgenden Elementen:

<servlet-name>	required
<url-pattern>	required	/xyz/abc => nur <WebAppURL>/xyz/abc\\\\/xyz/* => alle <WebAppURL>/*\\\\*.abc => alle <WebAppURL>/*/*.abc

<welcome-file-list>

Contains a list of files to be used if no file is specified in the URL.

WAR-Files

A war file (web application archive) is just a jar file. The structure is:

• \WEB-INF
  • [web.xml for servlet container]
  • [faces-config.xml for JSF]
  • [components.xml for Seam]
  • [pages.xml for Seam]
  • [<WarFileName>-ds.xml for JPA datasource configuration]
  • [other configuration files]
  • [Axis Web Services Directories] for Axis Web Service Implementations]
  • [\classes]
    • [servlet and utilities classes]
    • [\META-INF]
      • [persistence.xml]
  • [\lib]
• \META-INF
• [own directories]
• [own web files like html, jsp, css]

Applet Code within a Web-Application

An applet is executed on the client side (browser), not on the server side (servlet container). You need to place the applet class files in a location accessible from the browser, which means you have to treat them like normal files (like HTML or GIF files that you want the browser to load). Thus they need to go in the webapp directory tree, but not in the WEB-INF subdirectory. It is best to think of the set of applet class files as entirely different from the set of servlet class files. They will be loaded by different Virtual Machines, and may even have different versions of classes. It is a simple matter to configure your build environment (Ant or make) to create copies of common class files in the two different classpath directories.

Enterprise Application

EAR-Files

A ear file (enterprise application archive) is just a jar file. The structure is:

• \META-INF
  • application.xml
  • jboss-app.xml
• [\lib]
  • [libs]
• beans jar file
• [WAR file]

Any .jars put in a lib directory at the top-level of the .ear will be visible to all modules within the .ear. Note that this only applies to Java EE 5 implementations. In J2EE 1.4 and earlier, you'll need to add a Class-Path entry to the ejb-jar's MANIFEST.MF file to refer to the name of the library .jar in the .ear.

beans jar file

• \META-INF
  • ejb-jar.xml
  • persistence.xml
• <bean classes>

JNDI

The Java Naming and Directory Interface (JNDI) is part of the Java platform, providing applications based on Java technology with a unified interface to multiple naming and directory services. JNDI works in concert with other technologies in the Java Platform, Enterprise Edition (Java EE) to organize and locate components in a distributed computing environment. JNDI erlaubt die Unterstützung praktisch aller Arten von Namens- und Verzeichnisdiensten, insbesondere von:

• LDAP
• DNS
• NIS
• CORBA Namensdienst
• Dateisystem

JCA

The J2EE Connector architecture provides a Java technology solution to the problem of connectivity between the many application servers and today's enterprise information systems (EIS). The J2EE Connector architecture defines a standard architecture for connecting the J2EE platform to heterogeneous EIS systems. Examples of EIS systems include ERP, mainframe transaction processing, database systems, and legacy applications not written in the Java programming language. The J2EE Connector architecture enables an EIS vendor to provide a standard resource adapter for its EIS. The resource adapter plugs into an application server, providing connectivity between the EIS, the application server, and the enterprise application. An EIS vendor needs to provide just one standard resource adapter which has the capability to plug in to any application server that supports the J2EE Connector architecture. Multiple resource adapters (that is, one resource adapter per type of EIS) are pluggable into an application server. To achieve a standard system-level pluggability between application servers and EISs, the J2EE Connector architecture defines a standard set of system-level contracts between an application server and EIS. The resource adapter implements the EIS-side of these system-level contracts. An application server and an EIS collaborate to keep all system-level mechanisms, such as transactions, security, and connection management, transparent from the application components.

The J2EE Connector architecture (Version 1.0) defines the following set of system-level contracts:

• connection management
• transaction management
• security contract

The J2EE Connector architecture (Version 1.5) defines the following set of system-level contracts:

• transaction inflow contract
• message inflow contract
• lifecycle management
• work management

Resources

• Standard Java 6 Tutorial