301AA - Advanced Programming
Lecturer: Andrea Corradini
http://pages.di.unipi.it/corradini/
AP-08-EE: Java EE & Enterprise Java Beans
Overview
• Java EE
• Multi-tier applications
• Components in Java EE:
– Servlets / JSP (Java Server Pages) – EJB (Enterprise Java Beans)
èSection 14.5 of Component Software: Beyond Object-Oriented Programming. C. Szyperski, D.
Gruntz, S. Murer, Addison-Wesley, 2002.
2
Java Distributions
• Java Card
– allows Java-based applications (applets) to be run securely on smart cards
• Java SE (Standard Edition)
• Java EE (Enterprise Edition)
– Suite of specifications for application servers – Around 20 implementations available
– Reference implementation: Oracle Glassfish
• Java ME (Micro Edition)
– embedded and mobile devices, e.g. micro-controllers, sensors, gateways, mobile phones, personal digital assistants (PDAs), TV set-top boxes, printers…
• JavaFX
– software platform for creating and delivering desktop applications, as well as rich Internet applications (RIAs) that can run across a wide variety of devices.
3
Java EE
• Realizes a "standard" platform for the development, execution and management of enterprise applications:
– Multi-tier à structured into "levels"
– Web-enabled à accessible through the Web
– Server-centric à executed in a specific server environment
– Component-based à consisting of sw components running on one or more distributed server instances
• It is based on the Java SE platform to which it adds specifications and tools (API) ad hoc
• Shares the benefits of Java SE applications:
– One standard specification vs. many implementations – Implementations available for most host systems
– Portability, ease of development, reuse, security, etc.
Multi-tier Architecture
• “Abstract” architectural model for enterprise applications
– independent of technological choices (language, platform, etc.)
• Functionalities of the application are divided into 3 isolated "levels"
(Tiers):
– Client Tier à executes requests to the Middle-tier
– Middle Tier à manages requests from clients and processes application data – Data Tier à keeps data in permanent storage structures
• Java EE is a particular implementation of the model that focuses on the Middle Tier à Java EE Application Server
Client
Tier Middle Tier Data
Tier
Java EE: Multi-tier Architecture
ClientWeb
ClientB2B
WebTier
Connector/
Messaging Tier
Business
Tier Data Access
Tier
Legacy Tier
Data Tier
Client Tier Middle Tier Data Tier
Java EE Application Server
Java EE: Client Tier
• The Client Tier includes the client applications that
"use" the enterprise application by communicating with the Java EE Application Server
• Clients are usually running on hosts other than the one hosting the server
• Two types of client applications:
– Web Client à is a web browser that makes requests via HTTP to the Web Tier
– B2B Client à one or more applications that make requests to the Business Tier through SOAP / Web Services or Java RMI
Java EE: Web Tier
• The Web Tier consists of components that manage the
interactions between the Web clients and the Business Tier
• Main functions:
– dynamic generation (“on-the-fly”) of content for different clients – collection of input data that users send via the Web client
interface
– generation of output based on the Business Tier components – control of navigation flow on the client
– maintaining status for a user session
– basic application logic and temporary storage of information within Java components (e.g. JavaBeans)
Java EE: Web Tier
Technology Goal
Servlets Java classes that process HTTP requests and dynamically generate responses (HTML)
JavaServer Faces (JSF) Design framework for Web application user interface
JavaServer Faces Facelets Particular JavaServer Faces applications that use XHTML pages instead of JSP
Expression Language Set of standard tags used in JSP and Facelets to refer to Java EE components
JavaServer Pages (JSP) Text documents compiled and transformed into Servlets to add dynamic content to HTML pages
JavaServer Pages Standard Tag Library Tag library that collects features common to JSP pages
JavaBeans Components Java objects for temporary storage of the contents of an application
Java EE: Business Tier
• The Business Tier consists of components that provide the business logic of the application
Technology Goal
Enterprise JavaBeans (EJB) Components managed by the Application Server that encapsulate the main
functionalities of the application
JAX-RS RESTful Web Services API for creating REST Web Services (via HTTP GET and POST)
JAX-WS Web Service Endpoints API for creating and consuming Web Services XML / SOAP
Java Persistence API Entities API for mapping data contained in persistent storage systems and corresponding Java objects
Java EE Managed Beans Essentially EJBs that do not require security / transactional requirements
Java EE: Data Tier
• The Data Tier refers to the various “data sources”
from which the application can draw and includes:
– Relational Database Management Systems (MySQL, Oracle, etc.)
– Enterprise Resource Planning Systems (SAP) – Mainframes (IBM AS / 400)
• The data sources
– are located on hosts other than the one on which the Java EE Application Server is running
– are accessed by the Business Tier components
Java EE: Data Tier
Technology Goal
Java Database Connectivity API (JDBC) Low level API for accessing and retrieving data stored on permanent media. Typically used to execute SQL queries to a particular RDBMS
Java Persistence API (JPA) API for handling persistent storage of Java objects exploiting a Relational Database
Java EE Connector Architecture (JCA) API for connecting application servers and enterprise information systems (EIS, legacy systems),
Java Transaction API (JTA) API for defining and managing transactions between multiple and distributed data sources
Java EE Application Servers
• Server that implements the Java EE platform
• Hosts the Middle Tier components of a multi-tiered enterprise application
• Provides the standard services specified by Java EE to these components in the form of a container:
– concurrency management, scalability – security
– persistence, transactions
– life cycle management of software components
• “Famous” Java EE servers: GlassFish (open-source reference
implementation: Oracle till 2017, now Eclipse Foundation), JBoss AS (Red Hat), WebLogic (Oracle-BEA), WebSphere (IBM), etc.
– http://en.wikipedia.org/wiki/Comparison_of_application_servers#Java
Java EE Containers
• Interface between an application component and the low-level features provided by the platform to support that component
• The functionalities of a container are specified by the platform
• One type of container for each type of component
• Java EE Server provides the various containers with a homogeneous environment in which the functioning of each component of the application is guaranteed
Web Container
• Interface between web components and the web server
• A web component can be a Servlet, a JSF or JSP page
• Manages the component’s life cycle
• Dispatches requests to the various components of the application
• Provides interfaces to “contextual data” (e.g.
information on the current request)
Application Client Container
• Interface (gateway) between Java EE client applications and the Java EE server
• The clients are particular Java SE applications that use the Java EE server components
• Running on client machines (generally different from the Java EE server)
EJB Container
• Interface between Enterprise JavaBeans that implement the business logic of the
application and the Java EE server
• Running on the machine that hosts the Java EE server
• Manages the execution of the EJB components of the application
Life Cycle of Java EE Applications
• Development / deployment cycle
– Static content design (HTML, CSS, etc.)
– Dynamic content development (Servlets, JSPs, EJBs, etc.) – Deployment descriptors (web.xml, application.xml, ejb-
jar.xml, etc.)
– Packaging (JAR, WAR, EAR, etc.)
– Deployment packages (JAR, WAR, EAR, etc.) on Java EE server (e.g., JBoss AS)
– Management of Java EE applications running on the server
Life Cycle of Java EE Applications
Deployment Descriptors
• Files that contain the “instructions” for a given container on how to use and manage the Java EE components
– Safety
– Transactions – Persistence
• Customizable (XML-based)
• They guarantee the portability of the components
Java components for WEB applications
ClientWeb
ClientB2B
WebTier
Connector/
Messaging Tier
Business
Tier Data Access
Tier
Legacy Tier
Data Tier
Client Tier Middle Tier Data Tier
Java EE Application Server
Dynamic web contents
• A dynamic web page may vary its content
according to the parameters provided by the client at the time of the request
• A dynamic web page may show dynamic contents
• Client- vs. Server-side scripting: where is the code running?
• Client-side scripting: Dynamic content is generated by code running on the client
– Main client-side scripting language: JavaScript – Java components, now obsolete: Applets
Server-side scripting
• The dynamism concerns more than a single web page
• Dynamic content is generated by code running on the (web) server side
• It manages user sessions and controls the application flow
• HTML form, parameters in the request URL, type of browser used, etc.
• Main server-side languages: Perl, PHP, Java, ASP
• Server-side extensions: CGI, JSP, ASP.NET
Server-side web technologies
Java Servlet/Java Server Pages (JSP)
• A servlet is a Java Component designed to handle a web request
• Each servlet must implement the interface
javax.servlet.Servlet – It specifies life cycle methods
• Server request are handled by independent threads in the JVM
• A Java Server Page (JSP) is an HTML page with Java scripts
– Its compilation causes the execution of a servlet
CGI vs. Servlet/JSP
Servlet and Web Applications
• The Servlet Container provides "low level" services needed for the Servlets and JSPs lifecycle:
– HTTP connection management, sessions, threading, security, resource management, monitoring,
deployment, etc.
Java Servlet: Life Cycle
• In response to a request from the client, the container:
– Check that the Servlet has already been loaded
• If it is not, it will load the corresponding class and generate an instance
• Initialize the newly created instance by invoking the init method on it
– Invoke the service method corresponding to the
Servlet instance passing the objects representing the request and the response as arguments
• Servlet removal from the container is achieved by calling the destroy method
Loading/Instantiation
Class.forName().newInstance() Initialize
init()
Servicing
service()
Destroy
destroy()
Unload/Garbage Collector
finalize()
Incoming client requests for the Servlet S
Servlet JVM
Container
Servlet S
isLoaded S
NO YES
1 request = 1 thread
Enterprise Java Beens 3.2 (2013)
• Server-side components that implement the
“business logic” of an application
• EJBs cooperate within a Java EE server
• The possible “clients” of the EJBs are:
– Web Tier Components (local or remote to the server) – Remote clients (eg Java RMI)
– Web Service Client (HTTP / SOAP)
• The idea of EJBs is to move all the application logic out of the Web level, into a specially dedicated
layer
EJB 3.2 components
• Two main components defined by the standard:
– Session Beans à perform the application logic, manage transactions and access control
– Message-Driven Beans à perform actions
(asynchronously) in response to events (eg receiving a JMS message)
• Each of the two types of components has its own specific life cycle
• The behavior of each EJB component is specified through the use of metadata:
– Code annotations – XML descriptors
• Before EJB 3.0, the so-called Entity Beans were also considered EJB components
– Since they too were managed by the EJB container
• Entity Beans represent the tables of a relational DB
• Starting from EJB 3.0 the Entity Beans are no longer managed by the EJB container but use services implemented by an appropriate
interface (JPA, Java Persistence API)
EJB 3.2 components (note)
The EJB Container
The EJB Container
• The EJB instances are running within the EJB container. The container is a runtime
environment that controls an EJB component
instance and provides all necessary management services for its whole lifetime.
– Transaction management: ensuring transaction properties of multiple distributed transaction executions.
– Persistence management: ensuring a persistent state of an entity bean, which is backed up by database.
– Life cycle management: ensuring the EJB component state transitions in its life cycle.
The EJB Container (cont.)
• The EJB container provides an interface for the EJB
component to the outside world. All access requests to the EJB component and responses from the EJB
component must get through the EJB container.
• The EJB container isolates EJB component from direct access by its clients.
• The container will intercept the invocation from clients to ensure the persistence, properties of transaction, security of client operations on EJB.
• The EJB container is in charge of generating an EJB home object, which helps to locate, create, and remove the EJB component object.
EJB: Advantages
• Simplify the development of large distributed enterprise applications
– EJBs developers need to focus only on the logic and leave the rest to the EJB container
– UI development is simplified given the separation between interface and logic
– Portability of EJBs on other Java EE servers is guaranteed (as long as they implement at least the same specifications)
EJB: Disadvantages
• Until the EJB 2.1 (2003) specification, EJB
applications were difficult to develop, deploy and test
– Many file descriptors for configurations – Automatic unit testing impossible
– Much heavier than the competing Spring framework
• Several features changed since EJB 3.0
– Annotations instead of interface implementation – Adoption of Dependency Injection
– Asynchronous communication with EJB’s using futures
EJB: Session Beans
• Reusable components that contain the application logic
• Clients interact with Session Beans either locally or remotely
• Access is via invocation of EJB public methods
• Two types of Session Beans:
– Stateless Session Beans – Stateful Session Beans
EJB: Stateless Session Beans
• Performs a task on behalf of a client and does NOT maintain its status
– Or rather, it maintains it only for the duration of the invocation of the method
• It ends when the method call is returned
• Does not keep information in secondary memory (disk)
• They can be "shared" and are the most common EJBs
• Examples: sending emails, converting currency, ...
EJB: Stateful Session Beans
• Maintain client status information through multiple calls to EJB methods
• Release the state once the client requests it, or the bean "ends"
• You may need to keep the status on secondary memory
• Usually represents temporary entities such as the “shopping cart”
EJB: Message Driven Beans
• EJBs that process application messages in asynchronous mode
• Implemented as JMS listeners
• Similar to Stateless Session Beans
– They do not maintain client status information
• A single MDB can serve messages from multiple clients
• The MDBs do not expose interfaces such as Session Beans
Session Beans: Interfaces
• The Session Beans must define the interfaces with which they can be invoked by the clients
• The interfaces allow you to isolate the
underlying implementation (facilitating any future changes)
• Three possible interfaces:
– Remote Interface – Local Interface
– Web Service Interface
Component variety – applets, servlets, beans, and Enterprise beans
that wrap the bean’s class, to synthesize subclasses that combine container-sup- plied object and home code with the code found in the bean’s class, or even to synthesize classes that directly combine the implementation of the bean’s class and the container-specific code. (In the latter cases, reflection would reveal additional members on the bean’s class and, again, the EJB server could take deployment and runtime measures to prevent that.)
Beans of many flavors
There are four kinds of EJB beans – stateless session, stateful session, entity, and message-driven beans. Message-driven beans are new in EJB 2.0 and somewhat different from session and entity beans (they are described in the following subsection). The three flavors of session and entity beans are covered in more detail further below. They are all united by a common top-level con- tract between beans and containers and their use of deployment descriptors.
Session and entity beans in addition share the design of EJB object and EJB home interfaces. (These are not standardized Java interfaces but are synthe- sized according to a standard pattern for any given bean.)
Every EJB home interface has a standard method create to instantiate a bean.
In the case of entity beans it also has a standard method findByPrimaryKey to locate an existing instance by its primary key. A home interface can have addi- tional, bean-specific methods as specified in the deployment descriptor. As such methods are not associated with any specific bean instance, they roughly corre- spond to static methods on a Java class. The methods on an EJB object interface are all bean-specific as specified in the deployment descriptor.
The EJB container cycles beans through defined lifetime stages. Immediately after creation, setEntityContext or setSessionContext is called to establish a backlink to the container’s context for the new bean. Then ejbCreate is called, which is matched by a call to ejbRemove just before a bean instance is finally released. For entity beans, removal also implies deletion from the database as,
311
Figure 14.9 Isolation of EJB beans in containers via EJB home and EJB object interfaces. After Fig. 2-2 in Monson-Haefel, R. (2001) Enterprise JavaBeans, 3rdEdition, reprinted by permission of O’Reilly and Associates, Inc.
Remote or local
EJB Server EJB home
EJB object EJB bean EJB Container
Home
EJB Server
EJB home stub
EJB object stub Remote
or local Home
Client
8557 Chapter 14 p261-328 3/10/02 10:41 PM Page 311
Session Beans: Remote Interface
• Clients may be running on different JVMs than EJBs
• Used by:
– web components (eg Servlet) – other EJBs
– application client
• “Position” of the EJB is transparent to the client
• The Bean can be distributed à scalability
Session Beans: Local Interface
• Clients must be running on the same JVM as compared to EJBs
• Used by:
– web components (eg Servlet) – other EJBs
• “Position” of the EJB must be that of the client
• Strong coupling between client and EJB
Session Beans: Web Service Interface
• Only for "Stateless" Session Beans
• Clients are running on a different JVM than the EJBs
• Used by Web service clients through the
protocols provided by the specifications (SOAP / WSDL over HTTP)
• Clients can be implemented in any programming language
Stateless Session Beans: Life Cycle
• Instances created by the EJB container
• Kept in a "pool" of "ready" instances
• Given a method call from a client:
– The EJB container assigns to the call one of the ready bean instances
– Once the method is executed, the instance returns to the pool
Stateful Session Beans: Life Cycle
• The client starts a session
• The default bean constructor is invoked
• Resources are "injected" (if present)
• The bean method annotated with the
@PostConstruct tag is executed
• From this point on, the bean remains in the cache to perform other client requests
Message-Driven Beans: Life Cycle
• The bean receives a message
• The EJB container searches for an instance of the bean available in the pool
• If available, the instance is used
• Once the execution of the onMessage() method is completed, the instance returns to the pool
• Similar to the Stateless Session Bean
Java Persistence API (JPA)
• It allows to automatically store data contained in Java objects on relational DBs
• Object-Relational Mapping (ORM)
• Applications can manage relational DB tables as "normal" Java objects
• The Java classes (entities) correspond 1: 1 to the relational tables defined in the DB
JPA: Advantages
• It has its own SQL-like syntax for static and dynamic queries
– Java Persistence Query Language (JPQL) – Portability compared to various DBs
• It prevents the developer from writing “low level” JDBC / SQL queries
• Provides caching services and performance optimization transparently
