J2EE Chris Hundersmarck Maria Baron Jeff Webb. Java 2 Platform, Micro Edition (J2ME) Java 2...
-
Upload
maurice-johnson -
Category
Documents
-
view
229 -
download
0
Transcript of J2EE Chris Hundersmarck Maria Baron Jeff Webb. Java 2 Platform, Micro Edition (J2ME) Java 2...
J2EE
Chris HundersmarckMaria Baron
Jeff Webb
Java 2 Platform, Micro Edition (J2ME) Java 2 Platform, Standard Edition
(J2SE) Java 2 Platform, Enterprise Edition
(J2EE) (J2ME) ‘is a subset of’ (J2SE) and
(J2EE) ‘is a superset of’ (J2SE).
J2EE is…
A distributed multi-tiered application model for enterprise applications.
Divided into components according to function.
Components installed on different machines Client, Server, Database Server
Machines
Containers
Provide access to the underlying services of the J2EE Server environment.
Different types of containers for different types of components
The interface between a component and the low-level functionality that supports a component.
Containers
For example EJB container:
manages the execution of enterprise beans.
Web container manages the execution of JSP pages and
servlet components.
Containers
Client Tier
1. Web clients1. HTML, XML, etc..2. Applets
2. Application clients1. GUI2. Command line
Web Tier
1. Servlets2. JSP Pages
Web Components
JavaServer Faces
Lets you create user interfaces from a set of standard, reusable server-side components
Provides a set of JSP tags to access those components
Transparently saves state information and repopulates forms when they redisplay
JavaServer Faces
Provides a framework for implementing custom components
Encapsulates event handling and component rendering so you can use standard JSF components or custom components to support markup languages other than HTML
Lets tool vendors develop IDEs for a standard Web application framework
JSF Components
Each component represents one or more Web page elements
Simple components – individual components such as a text box
Compound components – comprised of multiple elements such as a table
Each JSF component has:
A list of child components A hashmap of attributes One or more validators One or more event handlers An identifier for an optional renderer
Components
All JSF components perform three fundamental tasks Render the component, typically by
generating markup Handle the component's events Validate the component's values
Benefits
Foster the creation of development tools that allow user interface designers to drag and drop components into a layout.
Developer(s) can write event-handling code that will allow the view components to interact with the application model.
Faster GUI creation for prototyping and rapid application development (RAD).
JSP And Java
JSF AND JSP
JSF is not bound to JSP - strict decoupling of components from their view rendering
Rendering is done by using a rendering kit
JSP is a required rendering kit but developers can also use custom rendering kits to render views
Business Tier
1. Enterprise Java Beans1. Session Beans2. Entity Beans3. Message-Driven Bean
Java Beans vs. Enterprise Beans
1. Java Beans are not considered J2EE components by the J2EE specification
2. Java Beans:1. Can exist on Server tier or Client tier.2. Manage communication between all three
tiers.
3. Enterprise Beans: 1. Only exist on Business Tier as part of the
Server Tier
Business Components
Enterprise Java Beans
Server-side component Encapsulates business logic Simplifies development
EJB container provides system-level services
Separates business logic from client. EJB are portable components.
Session Beans
1. Represents a single client.2. Client invokes the session bean's
methods.3. Performs work for the client.4. when the client finishes executing,
the session bean and its data are gone.
Session Beans
Two types of Session beans: Stateless Stateful
Entity Beans
1. Represents persistent data stored in one row of a database table.
2. If the client terminates or if the server shuts down, the underlying services ensure that the entity bean data is saved.
Entity Beans
What makes Entity Beans different from Session Beans? Persistence Shared Access Primary Key Relationships
Message-Driven Bean
1. Combines features of a session bean and a Java Message Service (JMS) message listener
2. Allows a business component to receive JMS messages asynchronously.
Message-Driven Bean
Message-driven beans have the following characteristics: They execute upon receipt of a single
client message. They are invoked asynchronously. They are relatively short-lived. They do not represent directly shared data
in the database, but they can access and update this data.
They can be transaction-aware. They are stateless.
Component Packaging
.jar - Java archive : classes and web content for a J2EE application
.war - web application archive .ear – enterprise archive
contains the whole application along with deployment descriptor that provides information about the application and its assembled components
Deployment
Deployment tool provides ability to configure and deploy a complex enterprise application onto the : Sun Java System Application Server or onto other application servers
What Is XML ?
Text-based markup language As with HTML, you identify data
using tags. Collectively, the tags are known as markup.
Unlike HTML, XML tags identify the data rather than specify how to display it.
What Is XML ?
<message> <to>[email protected]</to> <from>[email protected]</from> <subject>XML Is Really Cool</subject><text>How many ways is XML cool? Let me count the ways... </text>
</message>
Java API for XML Processing
(JAXP) is for processing XML data using applications written in the Java programming language.
Leverages the parser standards: Simple API for XML Parsing (SAX)
parse your data as a stream of events
OR Document Object Model (DOM)
build an object representation of it.
Java API for XML Processing
Simple API for XML Parsing (SAX) It is read forward only SAX simply sends data to the
application as it is read Requires much less memory than DOM,
because SAX does not construct an internal representation (tree structure) of the XML data
Fast and efficient
Java API for XML Processing
Document Object Model (DOM) When you need to modify an XML
structure interactively in-memory structure (Object model) provides many powerful capabilities for
large-scale documents requires more complex coding
JAX-RPC
Java API for XML-based RPC Technology for building web
services and clients that use remote procedure calls (RPC) and XML
Remote procedure call is represented by an XML-based protocol such as SOAP
SOAP
SOAP specification defines the envelope structure encoding rules Conventions
for representing remote procedure calls and responses in XML.
These calls and responses are transmitted as SOAP messages (XML files) over HTTP.
SOAP
SOAP messages are complex
The JAX-RPC API hides this complexity from the application developer.
Web Service using JAX-RPC
On the server side, the developer specifies the remote procedures by defining methods in an interface (written in the Java programming language)
The developer also codes one or more classes that implement those methods
Web Service using JAX-RPC
A client creates a proxy (a local object representing the service) and then simply invokes methods on the proxy.
The developer does not generate or parse SOAP messages
The JAX-RPC runtime system converts the API calls and responses to and from SOAP messages.
Web Service using JAX-RPC
JAX-RPC client can access a web service that is not running on the Java platform, and vice versa.
Flexibility is possible because JAX-RPC uses World Wide Web Consortium (W3C) technologies:
HTTP, SOAP, WSDL WSDL: Web Service Description
Language. WSDL specifies an XML format for describing a service.
Web Service using JAX-RPC
Web Client Web Service
Web Service using JAX-RPC
Service Code Extends the java.rmi.Remote interface Methods must throw the
java.rmi.RemoteException or one of its subclasses
Method parameters and return types must be supported JAX-RPC types
Hello Web Service
package helloservice;
import java.rmi.Remote;import java.rmi.RemoteException;
public interface HelloIF extends Remote { public String sayHello(String s) throws
RemoteException;}
Hello Web Service
package helloservice;
import java.io.*;
public class HelloImpl implements HelloIF { public String message = "Hello ";
public String sayHello(String s) { return message + s; }}
package staticstub;import javax.xml.rpc.Stub;
public class HelloClient { private String endpointAddress;
public static void main(String[] args) { System.out.println("Endpoint address = " + args[0]);
Stub stub = createProxy(); stub._setProperty(javax.xml.rpc.Stub._ ENDPOINT_ADDRESS_PROPERTY, args[0]);
HelloIF hello = (HelloIF) stub; System.out.println(hello.sayHello("Duke!"));}
private static Stub createProxy() { return (Stub) (new MyHelloService_Impl().getHelloIFPort());
}}
package staticstub;import javax.xml.rpc.Stub;
public class HelloClient { private String endpointAddress;
public static void main(String[] args) { System.out.println("Endpoint address = " + args[0]);
Stub stub = createProxy(); stub._setProperty(javax.xml.rpc.Stub._ ENDPOINT_ADDRESS_PROPERTY, args[0]);
HelloIF hello = (HelloIF) stub; System.out.println(hello.sayHello("Duke!"));}
private static Stub createProxy() { return (Stub) (new MyHelloService_Impl().getHelloIFPort());
}}