Your Federal Quarterly Tax Payments are due April 15th Get Help Now >>

J2EE_annayi_lc by HC11111102254

VIEWS: 0 PAGES: 92

									J2EE : Why, What and How
    TM




         University of Texas at Dallas
                    Anna Yi




                                         1
             Objectives
• Why J2EE?
• What is J2EE?
• How to use J2EE?




                          2
Why J2EE?

            Motivation for 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
                                                                        3
Why J2EE?
            Two-tier Client/Server
                Architecture


              Client   Server




                                     4
Why J2EE?


       Simple Web Client/Server
• Interaction of two-tier architecture
• Client: simply accesses web pages
  through web browser
• Server: retrieves html documents




                                         5
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




                                              6
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




                                              7
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
                         Client               Server




    But what is the problem with this architecture?                             8
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



                                                 9
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
                                                 10
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)




                                                                       11
              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



                                           12
              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



                                                      13
What is J2EE?


  Thin-client Multi-tiered Architecture




                                      14
                      J2EE Tiers
• Client Presentation
    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

                                   15
J2EE Components & Services
• Components
   - 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
                                                        16
     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)
                                               17
18
What is J2EE?

                The Big Picture




                                  19
What is J2EE?

                     4-Tier Model
                                    Web Tier
       Client Tier


                                     EIS Tier




                                    Business
                                      Tier      20
What is J2EE?

                Commercial Platforms
 •   J2EE SDK 1.3 (Sun) *
 •   WebLogic (BEA Systems)
 •   WebSphere (IBM)
 •   iPlanet (Sun & NetScape)
 •   JBoss (Open source)




                                       21
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




                                                      22
Application Server: Key Services




                                   23
JBoss- Application Server




                            24
What is J2EE?

                J2EE Components

     • Java Servlets

     • JavaServer Pages (JSP)

     • Enterprise JavaBeans (EJB)




                                    25
26
27
28
29
30
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



                                                    31
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




                                                32
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.


                                             33
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

                                                                       34
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();
 %>

                                                                     35
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”) ; %>




                                                          36
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




                                                              37
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

                                                              38
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




                                                                         39
What is J2EE?

          Example: Travel Agency




                                   40
How to use J2EE?

               How to use J2EE ?
 • Using J2EE SDK 1.3.1 to Design,
   Develop, Assemble and Deploy
   Applications




                                     41
 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
                                                                42
                 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


                                                43
     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




                                                        44
    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
  – Remote Interface               Interface
  – Home Interface     Remote
                        Client                   EJB
  – Enterprise Bean Class           Home
                                   Interface
                                                 45
46
47
                    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();

  }




                                                               48
                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) ;

  }




                                                                   49
        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);
       }
                                                                        50
   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
                              WebAddressAccoun
• Build the database table    t
  – C:\> cloudscape –isql
                              urlName (PK)
                              urlDescription

                                                 51
52
                 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


                                                       53
         Example: BonusApp
• Objective:
   To calculate bonus
  for an employee

• 3-Tier Example using
  Session Bean

• 4-Tier Example using
  Entity Bean
                             54
      3 Tier Example: using session
                 bean
1.    Create HTML page
2.    Create Servlet
3.    Create the Session Bean
4.    Compile the Session Bean and Servlet
5.    Start the J2EE Application Server
6.    Start the Deploy tool
7.    Assemble the J2EE application
8.    Specify JNDI Name and Root Context
9.    Verify and Deploy the J2EE application
10.   Run the J2EE application
                                               55
    3 Tier Example: using session
               bean
• 3-tier
   – Html page
   – Servlet
   – Session Bean




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




                                                  59
Create Session Bean: CalcHome,
        Calc, CalcBean




                                 60
               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.



                                                                        61
                        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.



                                                                                      62
                         CalcBean.java




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


      HTML        Servlet          Session Bean
bonus.html   BonusServlet.java   CalcHome.java
                                 Calc.java

                                 CalcBean.java




                                                  64
   Start the Application Server
• Start the Application Server
  J2ee –verbose
• Start the deploytool
  deploytool




                                  65
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).



                                               66
2. Create a New EnterpriseBean




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




                                68
   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




                                               69
 Specifying a Resource Reference




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




                             71
Deploy the application




                         72
         Run the application




In the browser, type
http://localhost:8000/BonusRoot/bonus.html

• 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.

                                                              73
 4 Tier Example: using entity bean/
   cooperating enterprise beans
• 4-tier
   –   Html
   –   Servlet
   –   EJBs
   –   Database




                                  74
Create Entity Bean: Bonus Home
(Home interface), Bonus (Remote interface)




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




                                         76
 4 Tier Example: using JavaServer
              Pages
• 4-tier
   –   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.

                                                                            77
78
4 Tier Example: Bonus.jsp




                            79
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



                                          80
 Advantages & Disadvantages
• 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



                                                81
      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
                                           82
  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


                                                83
               Reference
• http://java.sun.com/j2ee
• http://www.utdallas.edu/~chung/SA/2client
  .pdf
• http://sdmc.krdl.org.sg:8080/~judice/J2EE.
  pdf
• http://www.sun.com/developers/evangcent
  ral/presentations/j2eeoverview.pdf
• http://www.sun.com/developers/evangcent
  ral/presentations/J2EE.pdf
                                           84
    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.




                                        85
Design Patterns: Factory Method




                                  86
   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", 100000000.25d);
           // invoke business methods
           account.credit (200000000.25d);
           // remove the object
           account.remove ();
           }
   }



                                                                            87
         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.




                                                                              88
        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.




                                           89
        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.




                                     90
      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();
      ...
 }



                                                                  91
Core J2EE Pattern Catalog




                                                         92
    http://java.sun.com/blueprints/patterns/index.html

								
To top