1. University of Texas at Dallas Anna Yi
J2EETM : Why, What and How
University of Texas at Dallas
Anna Yi

2. Objectives Why J2EE? What is J2EE? How to use J2EE?
How to use j2EE to design, develop, assemble, and deploy Java applications
Accumulation of slides

3. Motivation for J2EE Need for
Why J2EE?
Need for
New multi-tier enterprise computing model in web environment
A way to bring in different elements of enterprise application
Web interface design
Transaction processing
Meeting non-functional system requirements:
Availability, reliability, enhanceability, performance, scalability, reusability, interoperability
Timely development and deployment
Enterprise means “server-side” computation

4. Two-tier Client/Server Architecture
Why J2EE?
Two-tier Client/Server Architecture
Server
Client

5. Simple Web Client/Server
Why J2EE?
Interaction of two-tier architecture
Client: simply accesses web pages through web browser
Server: retrieves html documents
It’s not very useful; not very intelligent
Give url, and web browser brings in web pages

6. CGI-based Web Client/Server
Why J2EE?
CGI-based Web Client/Server
Interaction of two-tier architecture
Client: uses service requiring 2ndary storage
Server: manipulates forms, Database updates, (primitive) electronic commerce
Fat Server/ Thin Client
i.e. order pizza, free after 30 min; should be a way to determine the time
Somebody has to remember the time that I ordered (server)

7. Java Applet-based Web Client/Server
Why J2EE?
Java Applet-based Web Client/Server
Interaction of two-tier architecture
Client: uses Java Applet for client-side computation
Server: provides Applet bytecode
Fat Client/Thin Server
Client to do stand-alone processing
But we cannot do important processing, such as done by CGI programming? Java’s utility is fairly limited

8. Two-tier Client/Server Architecture
Why J2EE?
Two-tier Client/Server Architecture
So, important processing needs to be run on the server
Then, Java needs to run on the server too to be more useful  enterprise
The server is almost like what CGI-programming does
Client: data access applying business logic and presentation of data (computation)
Server: serves only as service-database server, not application server web server
Enterprise has two different meaning
Application server: J2EE (platform for serving applications, JSP)
Client
Server
But what is the problem with this architecture?

9. Drawbacks of two tier application architecture
Why J2EE?
Drawbacks of two tier application architecture
Easy to deploy, but difficult to enhance or upgrade
Reusability of business and presentation logic difficult
Not scalable

10. Vision of J2EE An open standard Umbrella for anything Java-related
Why J2EE?
Vision of J2EE
An open standard
Umbrella for anything Java-related
For designing, developing, assembling, and deploying component-based enterprise applications
Separation of business logic from presentation
Reusability, enhanceability, scalability, interoperability
Enterprise means “server-side” computation

11. Separation of Business logic from Presentation logic
Why J2EE?
Separation of Business logic from Presentation logic
Presentation logic : display
Business logic : what the company wants to do
Example: the distribution of different sales figures by diff dept (business logic) can be represented in many different ways (pie chart, bar graph, etc)

12. Why J2EE? Simplifies the complexity of a building n-tier application
Standardizes an API between components and application server container
J2EE Application Server and Containers provide the framework services

13. What is J2EE?
Defines the standard for developing multitier enterprise applications
Simplifies enterprise applications by:
Basing them on standardized, modular components
Providing a complete set of services to those components
Handling many details of application behavior automatically, without complex programming
So J2EE comes up w/ solution; what is the solution?

14. Thin-client Multi-tiered Architecture
What is J2EE?
Thin-client Multi-tiered Architecture
So J2EE comes up w/ solution; what is the solution?

15. J2EE Tiers Client Presentation Presentation Logic Application Logic
HTML or Java applets deployed in Browser
XML documentations transmitted through HTTP
Java clients running in Client Java Virtual Machine (JVM)
Presentation Logic
Servlets or JavaServer Pages running in web server
Application Logic
Enterprise JavaBeans running in Server

16. J2EE Components & Services
Java Servlets
JavaServer Pages (JSP)
Enterprise JavaBeans (EJB)
Standard services & supporting technologies
Java database connectivity(JDBC) data access API
Java Messaging Service (JMS)
(Remote Method Invocations (RMI))
Extensible Markup Languages(XML)
JavaIDL (Interface Description Language)
JavaMail
Java Security
CORBA technology
Design Patterns
Components based model
Container-provided services
Design Patterns are oo reusable components (solutions to recurring problem)
MVC: architectural concept; in Smalltalk environments;
Java Beans:reusable unit of component; a java class w/ four kinds of special features 1: properties(get/set); 2:methods(internal,get/set);3.persistence;4.events

17. Advantages of Multi-tiers
Tiers separate functionality:
Presentation Logic, Business Logic, Data Schema
Easier upgrade since one tier can be changed without changing the rest
Lower deployment and maintenance cost
More flexible (can support changes), more extensible (can add functionality)

19. What is J2EE?
The Big Picture

20. What is J2EE?
4-Tier Model
Web Tier
Client Tier
EIS Tier
Business Tier

21. Commercial Platforms J2EE SDK 1.3 (Sun) * WebLogic (BEA Systems)
What is J2EE?
Commercial Platforms
J2EE SDK 1.3 (Sun) *
WebLogic (BEA Systems)
WebSphere (IBM)
iPlanet (Sun & NetScape)
JBoss (Open source)
Platform implements this architectural specification

22. What is Application Server
What is J2EE?
What is Application Server
Application servers enable the development of multi-tiered distributed applications. They are also called “middleware”
An application server acts as the interface between the database(s), the web servers and the client browsers

23. Application Server: Key Services

24. JBoss- Application Server

25. J2EE Components Java Servlets JavaServer Pages (JSP)
What is J2EE?
J2EE Components
Java Servlets
JavaServer Pages (JSP)
Enterprise JavaBeans (EJB)
Components based model
Container-provided services
Design Patterns are oo reusable components (solutions to recurring problem)
MVC: architectural concept; in Smalltalk environments;
Java Beans:reusable unit of component; a java class w/ four kinds of special features 1: properties(get/set); 2:methods(internal,get/set);3.persistence;4.events

31. Overview of Servlets Container-managed web components
What is J2EE?
Overview of Servlets
Container-managed web components
Replace Common Gateway Interface(CGI) or Active Server Pages (ASP)
Generate dynamic response to requests from web based clients
Synchronize multiple concurrent client request
Serve as client proxies

32. What is J2EE?
Servlet Operation
Server is Java program that runs as separate thread inside servlet container.
Servlet container is part of web server
It interact with web client using response request paradigm

33. JavaServer Pages (JSP)
What is J2EE?
JavaServer Pages (JSP)
Text based documents describe how to process a request and create a response
Contains HTML or XML and other JSP elements defined by JSP specification.
Are Installed on web server
are web components that sits on top of java servlet mode.

34. JSP Advantages Performance Programming
What is J2EE?
JSP Advantages
Performance
Runtime characteristics of servlets
uses Lightweight threads:
Doesn’t start new process for each request, Initialized
once and persists in memory for multiple requests, cached
Automatic recompilation of modified pages
Server side processing
Programming
Emphasize use of reusable components
Write Once , Run Anywhere properties
Extensible through custom tag libraries
Provides front end access mechanism to EJBs

35. Parts of JSP Pages Directive Declaration Raw HTML Action Scriplets
What is J2EE?
Parts of JSP Pages
Directive
page import=“java.util.”, MVCApp.Cart, MVCApp.CartItem” %>
Declaration
<%! Iterator it = null; CartItem ci = null; Vector cpi = null;%>
Raw HTML
<html><head><title>Shopping Cart</title></head></html>
Action
<jsp:usebean id =“Cart” scope = “session” class = “MVCApp.Cart”/>
Scriplets %
Cpi = cart.getCartItems ( );
it = cpi.iterator();
While (it.hasNext()){ci= (Cart Item)it.next();
%>

36. Parts of JSP Pages Expression
What is J2EE?
Parts of JSP Pages
Expression
<td<% = ci.getTitle() %></td>
<td align =“right”><%=ci.getQuantity()%></td>
Implicit Objects
<% string action = request.getParameter(“action”) ; %>

37. Enterprise Java Beans (EJBs)
What is J2EE?
Enterprise Java Beans (EJBs)
Entity Beans
Represent persistent business Entity
Persisted in storage system ( usually Database)
Might contain Application logic intrinsic to entity
Session Beans
Perform work for individual clients on the server
Encapsulate complex business logic
Can coordinate transactional work on multiple entity beans

38. States and Persistence
What is J2EE?
States and Persistence
Session beans can be
Stateless- belong to client for duration of a method call
Stateful- belong to client for duration of client conversation
Entity beans can have
Bean-managed persistence- The developer writes SQL code to retrieve,store and update database
Container managed persistence- The developer provide database mapping information that allows the container to manage persistence

39. Example of EJB Application
What is J2EE?
Example of EJB Application
It consists of number of clients accessing session beans and entity beans
Each Session bean provides specialized processing on behalf of client
e.g. Travel Agent session bean makes travel reservations while Flight Scheduler bean schedules planes to fly on various routes.
Each Entity Bean represent different type of business entity.
e.g.Passengers, seats, planes, flights are entity beans

40. Example: Travel Agency
What is J2EE?
Example: Travel Agency

41. How to use J2EE?
How to use J2EE ?
Using J2EE SDK to Design, Develop, Assemble and Deploy Applications

42. How to run J2EE application on J2EE SDK 1.3.1
Preparation
Write and compile codes
<Start J2EE SDK> to Assemble, Deploy, and Run the application
Packaging
Creating the J2EE Application (.ear)
Creating the Enterprise Bean (.jar)
Creating the Web Client (.war)
Deploying
Running

43. Preparation Install J2EE SDK 1.3.1 on your system
Set Environment Variables
JAVA_HOME
= root directory of J2SE SDK installation
J2EE_HOME
= root directory of J2EE SDK installation
PATH
= %PATH%;%JAVA_HOME%\bin;%J2EE_HOME%\bin
CLASSPATH
= %CLASSPATH%;%J2EE_HOME%\lib\j2ee.jar

44. Creating Web Component
When web client such as browser communicates with J2EE application, it dose so through server-side objects called Web components
Writes and compiles the source code
Bundles the .class, .jsp, .html files into WAR file

45. Creating Enterprise Bean
An enterprise bean is a server-side component that contains the business logic of an application
Write and compile the source code
Package the bean’s classes into EJB JAR file
Remote Interface
Home Interface
Enterprise Bean Class
Remote
Client
Interface
Home
EJB

48. Remote Interface WebAddressAccount.java
defines the business methods that a client may call. The business methods are implemented in the enterprise bean code
public interface WebAddressAccount extends EJBObject {
public String getUrlName();
public String getUrlDescript(); }

49. Home Interface WebAddressAccountHome.java
defines the methods that allow a client to create, find, or remove an enterprise bean
public interface WebAddressAccountHome extends EJBHome {
public WebAddressAccount create(String urlName, String urlDescript);
public WebAddressAccount findByPrimaryKey(String urlName) ; }

50. Enterprise Bean Class WebAddressAccountBean.java
implements the business methods
public class WebAddressAccountBean implements EntityBean {
public String getUrlName() { return urlName; }
public String getUrlDescript() { return urlDescript; }
public String ejbCreate( String urlName, String urlDescript) {
insertRow( urlName, urlDescript); }
public String ejbFindByPrimaryKey(String primaryKey) {
result = selectByPrimaryKey(primaryKey);

51. Start J2EE SDK to Assemble, Deploy, and Run the application
Start Cloudscape database server.
C:\> cloudscape –start
Start J2EE server
C:\> j2ee –verbose
Start deploytool
C:\> deploytool
Build the database table
C:\> cloudscape –isql
WebAddressAccount
urlName (PK)
urlDescription

53. Packaging Create an Enterprise Archive (EAR) file
ProjectApp.ear
Add Java Archive (JAR) files and Web Archive (WAR) files to the EAR
WebAddressAccountJAR: contains the enterprise bean files and related files
ProjectWAR: contains the Web Component files and related files

54. Example: BonusApp Objective: To calculate bonus for an employee
3-Tier Example using Session Bean
4-Tier Example using Entity Bean

55. 3 Tier Example: using session bean
Create HTML page
Create Servlet
Create the Session Bean
Compile the Session Bean and Servlet
Start the J2EE Application Server
Start the Deploy tool
Assemble the J2EE application
Specify JNDI Name and Root Context
Verify and Deploy the J2EE application
Run the J2EE application

56. 3 Tier Example: using session bean
Html page
Servlet
Session Bean

57. bonus.html <HTML> <BODY BGCOLOR = "WHITE">
<BLOCKQUOTE>
<H3>Bonus Calculation</H3>
<FORM METHOD="GET"
ACTION=“bonusServlet">
<P>
Enter social security Number:
<INPUT TYPE="TEXT" NAME="SOCSEC"></INPUT>
Enter Multiplier:
<INPUT TYPE="TEXT" NAME="MULTIPLIER"></INPUT>
<INPUT TYPE="SUBMIT" VALUE="Submit">
<INPUT TYPE="RESET">
</FORM>
</BLOCKQUOTE>
</BODY>
</HTML>

59. BonusServlet.java public class bonusServlet extends HttpServlet {

60. Create Session Bean: CalcHome, Calc, CalcBean

61. CalcHome.Java
BonusServlet does not work directly with the session bean, but creates an instance of its home interface. The home interface extends EJBHome and has a create method for creating the session bean in its container.

62. Calc.java
When the home interface is created, the J2EE application server creates the remote interface and session bean. The remote interface extends EJBObject and declares the calcBonus method for calculating the bonus value. This method is required to throw javax.rmi.RemoteException, and is implemented by the CalcBean class.

63. CalcBean.java
The session bean class implements the SessionBean interface and provides behavior for the
calcBonus method. The setSessionContext and ejbCreate methods are called in that
order by the container after BonusServlet calls the create method in CalcHome.

64. Source Codes CalcHome.java bonus.html Session Bean Servlet HTML
BonusServlet.java
bonus.html
Session Bean
Servlet
HTML
Calc.java
CalcBean.java

65. Start the Application Server
J2ee –verbose
Start the deploytool
deploytool

66. Assemble the J2EE Application
1. Create a new J2EE application (BonusApp.ear).
2. Create a new enterprise bean (CalcBean.jar).
3. Create a new web component (Bonus.war).
4. Specify JNDI name for the enterprise bean (calcs).
5. Specify the Root Context for the J2EE application (BonusRoot).

67. 2. Create a New EnterpriseBean

68. 3. Create a new web component (Bonus.war).

69. JNDI Names and Resource References
JNDI: Java Naming and Directory Interface
J2EE components locate objects by invoking the JNDI lookup method
The JNDI name of a resource and the name of the resource reference are not the same
This approach to naming requires that you map the two names before deployment

70. Specifying a Resource Reference
The WebAddressAccountBean code refers to the database as follows:
private String dbName = "java:comp/env/jdbc/WebAddressAccountDB";

71. Mapping Resource Reference to JNDI Name

72. Deploy the application

73. Run the application
In the browser, type
Fill in a social security number
• Fill in a multiplier
• Click the Submit button. BonusServlet processes your data and returns an HTML page with the bonus calculation on it.

74. 4 Tier Example: using entity bean/ cooperating enterprise beans
Html
Servlet
EJBs
Database

75. Create Entity Bean: Bonus Home (Home interface), Bonus (Remote interface)

76. Create Entity Bean: Bonus Home (Home interface), Bonus (Remote interface)

77. 4 Tier Example: using JavaServer Pages
Client
JSP
EJBs
Database
JavaServer Pages (JSP) technology lets you put segments of servlet code directly into a static HTML page. When the JSP Page is loaded by a browser, the servlet code executes and the application server creates, compiles, loads, and runs a background servlet to execute the servlet code segments and return an HTML page or print an XML report.

79. 4 Tier Example: Bonus.jsp

80. Modifying the J2EE Application
Change the source code
Recompile it
Redeploy the application
Select Tools -> Update Files
Select Tools -> Deploy Or
Select Tools -> Update And Redeploy

81. Advantages & Disadvantages
Learning curve
Overhead of a layered architecture: no direct communication between layers that are apart, affecting performance
Moving target, i.e. upgraded versions

82. Conclusion : Summary
Need for server-side/enterprise processing with enhanceability, reusability, and scalability
J2EE as a web-based, component-based multi-tiered client/server architecture
Designing, developing, assembling, and deploying java applications using a platform

83. Conclusion: Research Issues
(Evolving)Vision still to be realized
Non-functional characteristics (enhanceability, reusability, scalability, security, etc)
Integration with other technologies such as CGI-programming and CORBA
Fuller support for design patterns in software lifecycle

84. Reference http://java.sun.com/j2ee

85. Design Patterns: Factory Method
The Factory Method lets a class defer instantiation to subclasses
The Factory Pattern promotes loose coupling by eliminating the need to bind application-specific classes into the code.

86. Design Patterns: Factory Method

87. Design Patterns: Factory Method
The equivalent code :
The EJB Client code to talk to an EJB
import javax.naming.*;
public class EJBClient {
public static void main (String[] argv) {
// get the JNDI naming context
Context initialCtx = new InitialContext ();
// use the context to lookup the EJB Home interface
AccountHome home=(AccountHome)initialCtx.lookup("Account");
// use the Home Interface to create a Session bean object
Account account = home.create (10001, "Athul", d);
// invoke business methods
account.credit ( d);
// remove the object
account.remove (); }

88. Design Patterns: Facade
The JMS class hierarchy can be somewhat daunting at first glance.
The relationships between the classes are straight forward,
but they require a sequence of code that is often repeated within a JMS application.

89. Design Patterns: facade
The JMS Connection and Session Types Depending upon the message-delivery paradigm you choose, your code must work with the correct ConnectionFactory, Connection, and Session classes. Each interface has a subclass for both the publish/subscribe (Topic) and point-to-point (Queue) message models.

90. Design Patterns: Facade
Topic and Queue Subclasses
Topic and Queue extend the Destination abstract interface. Subsequently, MessageProducer and MessageConsumer have subclasses for both message models.

91. Design Patterns: Facade
The com.JMSFacade Package This is an example of importing and creating the JMS Facade class, JMSManager:
import com.JMSFacade;
import javax.jms.*;
public class myClass {
JMSManager jmsMgr = new JMSManager();
... }

92. Core J2EE Pattern Catalog