Vorlesung Internet Technologien - J2EE by usr10478

VIEWS: 27 PAGES: 22

									                    J2EE
                    Java 2 Plattform, Enterprise Edition


Dr. Martin Kramer




      Anforderungen an
      Enterprise Anwendungen

  Enterprise Anwendungen benötigen oft folgende Features:

      •   Last-Ausgleich
      •   Transaktions- Management
      •   Persistenz
      •   Zuverlässigkeit
      •   Sicherheitsmechanismen
      •   Leichte Konfigurierbarkeit
      •   Kommunikation                       Ist J2EE die Medizin ?!?
     Warum J2EE?


• RAD: Rapid Application Development

• Zuverlässigkeit

• Offene Standards

• J2EE ist ein Standard mit Industry Momentum




Was sind die Vorteile?


• Portierbarkeit

• Skalierbarkeit

• Modularität

• Wiederverwendbarkeit

• Flexibilität

• Vereinfachte Nutzung von Middleware
 J2EE - Definition

An environment for developing and deploying
enterprise applications.

The J2EE platform consists of a set of
   ?services,
   ?application programming interfaces (APIs), and
   ?protocols
that provide the functionality for developing
multitiered Web-based applications.

Source: Sun, The J2EE Tutorial, Glossary




 WORA



                "Write Once, Run Anywhere”




                    Wie wird das erreicht    ?
Rollen bei Entwicklung von
J2EE Anwendungen


          Anwendung             Wird von
                                Applikations-
                                entwicklern
                                erstellt

          J2EE APIs

                                Von Sun
                                standardisierte
                                Interfaces
   Service Provider Interface


                                Wird von Product
  App. Server Implementierung   Providern zur
                                entwickelt und
                                vertrieben




J2EE Lizenznehmer
    Der Application-Server Markt

Marktanteil 2000


            1% 7%                     BEA Weblogic
          3%
                                      IBM Websphere

                                      Sun iPlanet

            33%        56%            Oracle App-
                                      Server
                                      Other




    Wichtige J2EE APIs


•   Enterprise Java Beans (EJB)
•   Java Server Pages
•   Java Servlets
•   Java Naming and Directory Interface (JNDI)
•   Java Transaction Service (JTA)
•   Java Message Service (JMS)
•   CORBA (IDL)
•   Java Database Connectivity (JDBC)
  Wichtige J2EE Technologien (1)

• Internet Protokolle
   – TCP/IP
   – HTTP 1.0 (V1.1 in einigen Implementationen)
   – SSL 3.0
• Objekttechnologien
   – RMI, RMI over IIOP
   – CORBA / IDL / IIOP
• Messaging:
   – Java Mail API
   – Java Messaging Service
• Datenformate
   – HTML
   – XML




  Wichtige J2EE Technologien (2)

• Datenzugriff:
   – JDBC
   – JDBC 2.0 Extension API (z.B. Connection Pooling)
• Transaktionen
   – Java Transaction API
   – Java Transaction Service
• JNDI
• Connector Architecture
   – Zugriff auf ERP, Legacy Systeme,
   – Hersteller stellen Konnektoren zur Verfügung
 Das MVC Design Pattern
 Wie können mehrere Clients unterstützt werden




 Vermischung von Datenbankzugriff
 und Presentation-Code


• Es müssen unterschiedliche Anwendungen für
  jeden Client-Typ entwickelt werden

• Nicht-Interface Code muss in jedem Client
  dupliziert werden

• Langsam aber sicher werden sich die Teile, die
  Kernfunktionalität enthalten, auseinander
  entwickeln
     Trennung von Ansicht und Inhalt:
     Das MVC Paradigma




     Vereinfachung: Model-Delegate
     Beispiel: Swing Tabelle


                                                JTable




Interface TableModel{                          «interface»
    getColumnClass(int index);                TableModel
    getColumnName(int index);
    getRowCount();
    getColumnCount();
    getValueAt(int x, int y);                  MyModel

    isCellEditable(int x, int y);
    setValueAt(Object value, int x, int y);
}
  Vorteile des MVC Paradigmas


• Mehrere Clients können auf ein Modell zugreifen

• Einfachere Entwicklung von neuen Clients

• Einfacher Austausch der Modell-
  Implementierung

• Modell und Ansicht können getrennt entwickelt
  werden




   J2EE Architektur
   High-Level Überblick
   J2EE Architektur (detailliert)




   J2EE Anwendungs-Szenarien

Beispiel Szenarien
•Einfaches Web Szenario
•Multi-Tier Web Szenario
•Standalone Client (Web)
•Standalone Client (EJB)
•B2B Szenario
 Einfaches Web Szenario




Multi-Tier Web Szenario
Standalone Client (Web basiert)




Standalone Client (EJB basiert)
 B2B Szenario




J2EE Komponenten

            Werden von
            Anwendungsentwicklern erstellt


            Werden von App-Server Herstellern
            vertrieben


            Werden von Legacy- oder ERP-
            System Herstellern zur Verfügung
            gestellt
Vorteile

                Sind aus der OO
                Anwendungsentwicklung bekannt


                Sind zwischen Client und
                Compenent geschaltet, bieten
                Resource Pooling,
                Transaktionmanagement, etc.


                Verstecken Komplexität beim
                Zugriff auf Legacy-Systeme




  Enterprise Java Beans (EJBs)


• EJBs: Java Beans für die Server-Seite
• Vergleichbar zu SQL-Stored Procedures
• EJBs werden von der Laufzeitumgebung, den sog.
  Containern verwaltet
• Container bieten Enterprise Features
• Der Deployment Descriptor enthält
  Meta-Informationen: Vertrag
  zwischen Container und Bean
  Integration von
  EJBs und Containern

                                              EJB Container
                                                                       Contract
                       EJB Finder
         lookup                                 ejbLookup



            create
                       EJB Factory          ejbCreate             EJB
Client      methods
                                                            Deployment Descriptor
                       EJB Object           methods
                                                                Environment
         detroy

                      EJB Container           ejDestory




         Klassen des Container Betreibers   Klassen des EJB-Entwicklers




  Arten von EJBs

                                      EJB


         Session Bean                                 Entity Bean




                                        Container                   Bean
Stateless            Stateful           Managed ...               Managed ...

                                                      ... Persistence
                                                      ... Transaction Demarcation
    Rollen


•   J2EE Product Provider
•   Application Component Provider
•   Application Assembler
•   Deployer
•   System Administrator
•   Tool Provider




    Deployment


• Das Deployment von J2EE Anwendungen geschieht in
  Form von set of nested units
    – JAR Datei (EJB, Client .class Dateien)
    – EAR Datei
    – WAR Datei (HTML, GIF, JSP)

• Jede Unit enthält einen Deployment Descriptor
    – XML Datei
    – Deklarative Beschreibung der Einsatzparameter
    – Wird normalerweise von GUI-Tools erstellt
  Java Server Pages


• JSP ist ein Template Standard für
  HTML, XML, WML...

• Einbettung von Java Skripten in HTML

• Skripte erzeugen den dynamischen
  Anteil von HTML-Seiten

• Antwort auf Microsofts ASPs




  Technologie von
  Java Server Pages


• JSPs beruhen auf der Servlet Technologie
• JSPs werden automatisch zu Servlets konvertiert und
  kompiliert
• JSPs enthalten folgende Bestandteile
   – Statischer HTML-Code
   – Directives regeln die Zusammenarbeit mit
     Web Containern
   – Scripting Elements werden in den Servlet-Code
     eingebunden
   – <jsp:XXX.../> werden zu Methodenaufrufen zu
     Beans oder der Servlet API konvertiert
  Code-Beispiele

• Directives
      <%@ import = „java.util.*“ %>
      <%@ page errorpage=„errorpage.html“>
• Deklarationen
       <%! int counter=0;
           public void jspInit(){
                    System.out.println(„init...“);
           }
      %>
• Scriptlets
      <% for(int i=0;i<10;i++)
             //do something
      %>
• Expressions
      <%=counter++%>




Bsp: Positionen einer Rechnung (1)


1. Packages importieren:


  <%-- invoice.jsp --%>


  <%-- setting up an error page --%>
  <%@ page errorPage=„/jspInvoice/errorpage.html“ %>


  <%-- import needed classes --%>
  <%@ page import = „java.util.*“ %>
Bsp: Positionen einer Rechnung (2)

2. Invoice Nr. und Tabellenkopf:
 <jsp:useBean id=„invoice“ scope = „session“
 class=„com.ponton.Invoice“ />
 <HTML>
 <HEAD><TITLE>Rechnung</TITLE></HEAD>
 <BODY><H1>Rechnung Nr. <%=invoice.getNumber()%><H1>
 <TABLE BORDER=„0“ CELLPADDING=„0“ CELLSPACING=„0“>
            <TR BGCOLOR=„#406E6E“>
                    <TD WIDTH=„150“>Name</TD>
                    <TD WIDTH=„150“>Artikel</TD>
                    <TD WIDTH=„100“>Preis</TD>
            </TR>
 …




Bsp: Positionen einer Rechnung (3)

3. Ausgabe aller Rechnungpositionen
<%      Set itemSet = invoice.getItems();
        for(Iterator iter = itemSet.iterator();iter.hasNext();){
            Map.Entry entry = (Map.Entry)iter.next();
            InvoiceItem item = (InvoiceItem)entry.getValue();
%>
<TR>
            <TD>Name:    <%item.getName()></TD>
            <TD>Number: <%item.getNumber()></TD>
            <TD>Price:   <%item.getBasePrice()> Euro</TD>
</TR>
<%
        }
%>
</TABLE></BODY></HTML>
     Java/HTML Entpflechtung:
     Tag Libraries


• Hintergrund: Die starke Vermischung von
  grafischem Design (Präsentation) und
  Programmlogik ist nicht wünschenswert

• Tag Libraries ist eine Technologie, die
  Scriptlets von grafischen Elementen trennt

• In JSPs werden Custom Tags eingebettet, die
  in einer getrennten XML definiert sind




     Bsp: Iteratoren

<%
      Iterator i = cart.getItems().iterator();
      while (i.hasNext()) {
         ShoppingCartItem item = (ShoppingCartItem)i.next();

%>

      <tr>
        <td align="right" bgcolor="#ffffff">
           <%=item.getQuantity()%>
      </td>

<%
      }
%>
    Bsp: Iteratoren mit Tag Library

<logic:iterate id="item"
collection="<%=cart.getItems()%>“
>

<tr>
        <td align="right" bgcolor="#ffffff">
              <%=item.getQuantity()%>
        </td>
        ...

</tr>

</logic:iterate>




    J2EE in Aktion


• J2EE von Sun herunter laden und installieren
• Environment Variablen setzen
• Jakarta Ant installieren
• In der Console starten: j2ee –verbose
• Web-Server testen:
  http://localhost:8000
• Deploytool von der Console starten:
  deploytool
• EJB/JSP entwickeln und deployen
Vorführung am Live-System

								
To top