Below is a list of specifications for Java EE 7 technologies. For more information, check out the JSR pages:
Enterprise JavaBeans Technology
The Enterprise JavaBeans (EJB) component, or enterprise component, is a collection of code that contains fields and methods for implementing business logic modules. You can imagine an enterprise component as a building block that can be used separately or together with other enterprise components to execute business logic on a Java EE server.
Enterprise components are session or message-driven components.
The session component is a temporary dialogue with the client. When the client completes execution, the session bean and its data disappear.
The message-driven component combines the functions of a session component and a message receiver, which allows the business component to receive messages asynchronously. These are typically Java Message Service (JMS) messages.
In the Java EE 7 platform, new enterprise component features include the following:
The Java EE 7 platform requires Enterprise JavaBeans 3.2 and Interceptors 1.2. The Interceptors specification is part of the EJB specification.
Java Servlet Technology
Java Servlet technology allows you to define HTTP-specific servlet classes. The servlet class extends the capabilities of servers hosting applications that are accessed through a request-response programming model. Although servlets can respond to any request, they are commonly used to extend applications hosted on web servers.
In the Java EE 7 platform, new features in Java Servlet technology include the following:
Non Blocking I / O
HTTP protocol update
The Java EE 7 platform requires Servlet 3.1.
JavaServer Faces Technology
JavaServer Faces is a user interface framework for building web applications. The main components of JavaServer Faces technology are:
GUI component framework
A flexible model for rendering components in various types of HTML or in different languages and markup technologies. The Renderer object generates markup for visualizing the component and converts the data stored in the model object into types that can be represented in the form.
Standard RenderKit for creating HTML 4.01 markup.
The following functions support GUI components:
Input confirmation
Event handling
Transforming data between model objects and components
Creating a managed model object
Page Navigation Configuration
Expression Language (EL)
All of these features are available using standard Java APIs and XML-based configuration files.
In the Java EE 7 platform, new features in JavaServer Faces technology include the following:
The Java EE 7 platform requires JavaServer Faces 2.2 and Expression Language 3.0.
JavaServer Pages Technology
JavaServer Pages (JSP) technology allows you to place snippets of servlet code directly in a text document. A JSP page is a text document that contains two types of text:
Static data that can be expressed in any text format, such as HTML or XML
JSP elements that determine how a page creates dynamic content
For information on JSP technology, see the Java EE 5 Tutorial at http://docs.oracle.com/javaee/5/tutorial/doc/ .
The Java EE 7 platform requires JavaServer Pages 2.3 for compatibility with earlier releases, but it is recommended that you use Facelets as a display technology in new applications.
JavaServer Pages Standard Tag Library
The JavaServer Pages Standard Tag Library (JSTL) includes the core functionality common to many JSP applications. Instead of mixing tags from multiple vendors in your JSP applications, you use one standard tag set. This standardization allows you to deploy applications in any JSP container that supports JSTL, and increases the likelihood of optimizing tag implementations.
JSTL has an iterator and conditional tags for flow control, tags for managing XML documents, internationalization tags, tags for accessing databases using SQL, and tags for commonly used functions.
The Java EE 7 platform requires JSTL 1.2.
Java Persistence API
The Java Persistence API (JPA) is a Java standards-based persistence solution. Persistence uses the object-relational mapping approach to bridge the gap between the object-oriented model and the relational database. The Java Persistence API can also be used in Java SE applications outside of the Java EE environment. Java Persistence consists of the following areas:
The Java EE 7 platform requires the Java Persistence API 2.1.
Java Transaction API
The Java Transaction API (JTA) provides a standard interface for distinguishing between transactions. The Java EE architecture provides automatic default adoption for transaction commit processing and transaction rollback. Automatic commit means that any other applications that view the data will see updated data after each read or write operation to the database. However, if your application performs two separate database access operations that are dependent on each other, you will want to use the JTA API to determine where the entire transaction, including both operations, starts, rolls back, and commits.
The Java EE 7 platform requires the Java Transaction API 1.2.
Java API for RESTful Web Services
The Java API for RESTful Web Services (JAX-RS) defines APIs for developing web services built in accordance with the Representational State Transfer (REST) architectural style. The JAX-RS application is a web application that consists of classes packaged as a servlet in a WAR file along with the required libraries.
The Java EE 7 platform requires JAX-RS 2.0.
Guided Beans
Managed components, lightweight container-managed objects (POJOs) with minimal requirements support a small set of basic services such as resource injection, lifecycle callbacks, and interceptors. Managed components are a generalization of the managed components defined by the JavaServer Faces technology and can be used anywhere in a Java EE application, not just web modules.
The Managed Beans specification is part of the Java EE 7 Platform Specification (JSR 342). The Java EE 7 platform requires Managed Beans 1.0.
Contexts and Dependency Injection for Java EE
Implementation of contexts and dependencies for Java EE (CDI) defines a set of contextual services provided by Java EE containers that allow developers to easily use enterprise components with JavaServer Faces technology in web applications. Designed for use with state objects, CDI also has much wider use, which gives developers more flexibility to integrate various types of components in loosely coupled, but type-safe ways.
The Java EE 7 platform requires CDI 1.1.
Dependency Injection for Java
Dependency injection for Java defines a standard set of annotations (and one interface) for use in injected classes.
On the Java platform, EE CDI provides support for dependency injection. In particular, you can only use injection points in a CDI-enabled application.
The Java EE 7 platform requires dependency injection for Java 1.0.
Bean Check
The Bean Validation specification defines a metadata model and API for validating data in JavaBeans components. Instead of distributing data validation across several layers, such as the browser and server side, you can define the limitations of validation in one place and divide them between different levels.
The Java EE 7 platform requires Bean Validation 1.1.
Java Messaging API
The Java Message Service API (JMS) is a messaging standard that allows Java EE application components to create, send, receive, and read messages. This provides a distributed connection that is loosely coupled, reliable, and asynchronous.
In the platform, new JMS features include the following.
The new simplified API offers a simpler alternative to the previous API. This API includes a JMSContext object in the JMSContext that combines the connection and JMSContext functions.
All objects with the close method implement the java.lang.Autocloseable interface so that they can be used in the try-with-resources Java SE 7 statement.
The Java EE 7 platform requires JMS 2.0.
Java EE Connector Architecture
The Java EE connector architecture is used by tool providers and system integrators to create resource adapters that support access to enterprise information systems that can be connected to any Java EE product. A resource adapter is a software component that allows Java EE application components to access and interact with the underlying EIS resource manager. Because the resource adapter is specific to its resource manager, for each type of database or enterprise information system, there is usually a different resource adapter.
The Java EE connector architecture also provides performance-oriented, secure, scalable, and message-based transactional integration of Java EE platform web services with existing EISs, which can be either synchronous or asynchronous. Existing applications and EIS, integrated through the Java EE connector architecture into the Java EE platform, can be represented as XML-based web services using the JAX-WS and Java EE component models. Thus, JAX-WS and Java EE Connector Architecture are complementary technologies for enterprise application integration (EAI) and end-to-end business integration.
The Java EE 7 platform requires the Java EE 1.7 connector architecture.
JavaMail API
Java EE applications use the JavaMail API to send email notifications. The JavaMail API consists of two parts:
The Java EE platform includes a service provider JavaMail API that allows application components to send mail over the Internet.
The Java EE 7 platform requires JavaMail 1.5.
Java Authorization Contract for Containers
The Java Container Authorization Contract (JACC) specification defines a contract between the Java EE application server and the authorization policy provider. All Java EE containers support this contract.
The JACC specification defines java.security.Permission classes that satisfy the Java EE authorization model. The specification defines the binding of decisions on access to containers to operations with instances of these permission classes. It defines the semantics of policy providers that use new permission classes to meet the authorization requirements of the Java EE platform, including the definition and use of roles.
The Java EE 7 platform requires JACC 1.5.
Java Authentication Service Provider Interface for Containers
The Java Container Authentication Service Provider Interface (JASPIC) interface specification defines a Service Provider Interface (SPI) by which authentication providers that implement message authentication mechanisms can be integrated into containers or client or server messaging environments. Authentication providers integrated through this interface work with network messages sent to them by calling containers. Authentication providers convert outgoing messages so that the source of each message can be authenticated by the receiving container, and the recipient of the message can be authenticated by the sender of the message. Authentication providers authenticate each incoming message and return to their calling containers the identity established by the message authentication.
The Java EE 7 platform requires JASPIC 1.1.
Java API for WebSocket
WebSocket is an application protocol that provides full duplex communication between two nodes over TCP. The Java API for WebSocket enables Java EE applications to create endpoints using annotations that specify endpoint configuration parameters and designate lifecycle callback methods.
The WebSocket API is new to the Java EE 7 platform. The Java EE 7 platform requires the Java API for WebSocket 1.0.
Java API for JSON Processing
JSON is a text-based data exchange format derived from JavaScript that is used in web services and other related applications. The Java JSON Processing API (JSON-P) allows Java EE applications to parse, transform, and query JSON data using an object model or stream model.
JSON-P is new to the Java EE 7 platform. The Java EE 7 platform requires JSON-P 1.0.
Concurrency Utilities for Java EE
Concurrency utilities for Java EE is a standard API for providing asynchronous capabilities to components of a Java EE application using the following object types: managed worker service, managed scheduled worker service, managed thread factory, and context service.
Concurrency Utilities for Java EE - New to the Java EE 7 Platform. Java EE 7 Platform requires concurrency utilities for Java EE 1.0.
Packaged Applications for the Java Platform
Batch jobs are tasks that can be completed without user intervention. Batch applications for the Java platform specification is a batch environment that provides support for creating and running batch jobs in Java applications. A batch environment consists of a batch runtime, an XML-based job specification language, a Java API for interacting with a batch runtime, and a Java API for implementing package artifacts.
Packaged applications for the Java platform are new to the Java EE 7 platform. The Java EE 7 platform requires bundled applications for the Java 1.0 platform.
To test the technology of older versions of Java EE, take a look at the following links: