Send the link below via email or IMCopy
Present to your audienceStart remote presentation
- Invited audience members will follow you as you navigate and present
- People invited to a presentation do not need a Prezi account
- This link expires 10 minutes after you close the presentation
- A maximum of 30 users can follow your presentation
- Learn more about this feature in our knowledge base article
Do you really want to delete this prezi?
Neither you, nor the coeditors you shared it with will be able to recover it again.
Make your likes visible on Facebook?
Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.
Transcript of Java EE
basis: Java programming language and JVM
multi tiered architecture
delivers scalability, accessibility and manageability
supports the development of large scaled distributed applications
splits up the implementation work to
business and presentation logic by developers
standard system services provided by Java EE platform
application logic divided into components according to function
components are installed on various machines - depending on the tier where they belong to
based on client-server architecture
provides a model to create flexible and reusable applications
Most of Java EE applications are 3-tiered applications
Distributed over 3 locations:
Java EE server
database/legacy machines (EIS)
Extension of the client-server model -> multi-threaded AppServer is placed between client application and back-end
Tiers might also be defined using logical boundaries:
Business logic tier (it might be multi-tiered => N-tiered architecture)
3-tiered architecture != MVC software design pattern
: Client <-> Middle <-> Data (communication between layers is bi-directional and always passes through the Middle tier)
: Client (View), Middle (Controller), Data (Model) (communication is in unidirectional; we could say that each "layer" is updated by the one at the left and, in turn, updates the one at the right –where "left" and "right" are merely illustrative)
Java EE components
Component = self-contained functional software unit
Types of components:
e.g: Dynamic web pages containing various types of markup language (HTML, XML, and so on) + Web browser
e.g: runs on a client machine (directly access enterprise beans)
CLI or Swing/AWT based applications
e.g: a web page received from the web tier can include an embedded applet (small appl. Running on JVM)
dynamically process requests and construct responses
created using JSF or JSP technology
Static HTML pages and applets
bundled with web components during application assembly but are not considered web components by the Java EE specification
Business code, which is logic that solves or meets the needs of a particular business
Handled by enterprise bean
receives data from client programs, processes it and sends it to the enterprise information system tier for storage
retrieves data from storage, processes it and sends it back to the client program
e.g: session beans, message-driven beans, java persistence entities
Development and deployment process can be divided into distinct subprocesses assignable to distinct roles due to reusable modules
Java EE Product Provider and Tool Provider
Application Component Provider
Enterprise Bean -, Web Component -, Application Client Developer
Application Deployer and Administrator
All the developers act as Application Component Providers / Assemblers / Sometimes integrators / Lead devs / TPLs
Release-engineers are responsible for building the deliverable + deployment / administration in productive-like environments.
Client / Server Model
Two-tiered, distributed application structure
= provider of a service (or resource or function, respectively).
= requester for the services of the server.
Describes the relationship of cooperating programs in an application
One of the central ideas of network computing, supported by multiple networking protocols
What is HTTP-protocol?
networking protocol for distributed, collaborative, hypermedia information systems
request-response protocol in the client-server computing model => it defines, how the client and server communicate with each other.
communication on the World Wide Web is based on this protocol.
Short history: 1991 – v0.9, 1996 – v1.0, 1999 – v1.1 -> used today
= user agents (like: browsers, search engine crawlers, mobile phones, etc.)
= service/resource providers. Identified / looked up by using URIs.
URIs might be classified as locators (URL) or names (URN) or both.
schema-names: ftp, http, mailto, file
define syntax and semantics of schema-specific-part
server is not required to retain any information related to the state of the conversation with the client during processing multiple requests.In most cases we need the state
a sequence of network request-response transactions
Generic message format
A Servlet is a Java-based
server side web technology
Technically, JAVA class conforms Java Servlet API
Extends capabilities of servers
Request-response programming model
: container initializes the servlet
: called in case of every incoming request (sep. thread)
: take servlet out of service
Assume that a user enters a Uniform Resource Locator (URL) to a web browser.
The browser then generates an HTTP request for this URL.
This request is then sent to the appropriate server.
The HTTP request is received by the web server.
The server maps this request to a particular servlet.
The servlet is dynamically retrieved and loaded into the address space of the server.
The server invokes the init() method of the servlet.
This method is invoked only when the servlet is first loaded into memory.
It is possible to pass initialization parameters to the servlet so it may configure itself.
The server invokes the service() method of the servlet.
This method is called to process the HTTP request.
You will see that it is possible for the servlet to read data that has been provided in the HTTP request.
It may also formulate an HTTP response for the client.
The servlet remains in the server’s address space and is available to process any other HTTP requests received from clients.
The service() method is called for each HTTP request.
The server may, at some point, decide to unload the servlet from its memory. Invoke destroy
The algorithms by which this determination is made are specific to each server.
The server calls the destroy() method to relinquish any resources such as file handles that are allocated for the servlet; important data may be saved to a persistent store.
The memory allocated for the servlet and its objects can then be garbage collected.
Let us consider a typical user scenario
Interface between component and low-level platform-specific functionality
Web, enterprise bean, application client
assembled into Java EE module
Other low-level functionalities
Assembly and Deployment
Specify container settings for each component
Customize the underlying support provided by the Java EE server
such services as security
Java Naming and Directory Interface (JNDI) API lookups
The deployment process installs Java EE application components in the Java EE containers
The runtime portion of a Java EE product, it provides EJB and web containers
Manages the execution of enterprise beans for Java EE applications
Manages the execution of web pages, servlets, and some EJB components for Java EE applications
Application client container
Manages the execution of application client components. (Application clients and their container run on the client)
Manages the execution of applets. Consists of a web browser and Java Plug-in running on the client together
Lightweight and extensible core
Easy-to-use Administration Console
Support clustering, load balancing
Java EE 6 support
Support latest technologies
EJB, JPA, JSF, CDI
Application delivered in
Java Archive (JAR) file
Web Archive (WAR) file
Enterprise Archive (EAR) file
Contains modules and deployment descriptors
Assemble a number of different Java EE applications using some of the same components
contain class files for enterprise beans and an EJB deployment descriptor. EJB modules are packaged as JAR files
contain servlet class files, web files, supporting class files, GIF and HTML files, and a web application deployment descriptor. Web modules are packaged as JAR files with a .war (web archive) extension.
Application client modules
contain class files and an application client deployment descriptor. Application client modules are packaged as JAR files
Resource adapter modules
contain all Java interfaces, classes, native libraries, and other documentation, along with the resource adapter deployment descriptor. Resource adapter modules are packaged as JAR files with an .rar (resource adapter archive) extension.
prevent disclosure of information to unauthorized individuals/systems
data cannot be modified undetectably
information must be available when it is needed
ensure data is genuine
implies one's intention to fulfill their obligations to a contract
“It means protecting information and information systems from unauthorized access, use, disclosure, disruption, modification, perusal, inspection, recording or destruction”
e.g. password hashing or encryption
e.g. HTTPS (HTTP over SSL/TLS)
e.g. WSS (SOAP message signing and/or encryption)
e.g. role based access control in web or ejb deployment descriptors or using metadata annotations
embedded in an application and is used to make security decisions
works with web services and incorporates security features