word image
Zusammenfassung

Java Server Pages (Script, Zusammenfassung)

2.994 / ~17 sternsternsternstern_0.25stern_0.3 Olga P. . 2012
<
>
Upload File

Zusammenfassung
Informatik

KV Zürich Business School

Meier, 2010

Olga P. ©

0.85 Mb
sternsternsternstern_0.25stern_0.3
ID# 20436







JSP


 

Inhalt

1        Hypertext Transfer Protocol 3

1.1          HTTP Allgemein. 3

1.2         POST / GET. 4

1.3          Error-Codes. 4

2       Sessions. 4

2.1         Allgemeines zu Sessions. 4

2.2         Sessions in JSP. 5

2.3         Wann wird eine Session beendet?. 5

3        JSP. 5

3.1          Syntax. 5

3.2         Aufbau. 6

3.2.1           Direktiven. 6

3.2.2           Skriptingelemente. 7

3.2.3           Action-Elemente. 8

3.3          Beispiel 9

4       Servlets. 10

4.1         Syntax. 10

4.2         Aufbau. 10

4.3         Beispiel 11

4.4         Konfiguration von web.xml 11

5        Beans. 12

5.1          Syntax. 13

5.2         Aufbau. 13

5.3          Beispiel 13

6       JDBC.. 13

6.1         Allgemeines. 13

6.2         Anwendung. 13

6.3         Hilfreiche Websiten. 13

 


 

1          Hypertext Transfer Protocol

1.1               HTTP Allgemein

 

Das Hypertext Transfer Protocol ist ein Protokoll zur Übertragung von Daten über ein Netzwerk. Es wird hauptsächlich eingesetzt, um Webseiten aus dem World Wide Web in einen Webbrowser zu laden.

 

Die Kommunikation mittels HTTP besteht immer aus einem Request und einer Response dazu.
(Request = Anfrage an den Server, Response = Antwort vom Server, siehe Bild)

 

Jede HTTP-Nachricht besteht dabei aus zwei Teilen, dem Header und dem Body. Der Header enthält Informationen über den Body, damit dieser vom Empfänger korrekt interpretiert werden kann. Der Body enthält schließlich die Nutzdaten.

Ein Beispiel eines Headers:

 

1.2              POST / GET

Zur Übergabe von Parametern via HTTP gibt es zwei bekannte Methoden: Die GET-Methode und die POST-Methode.

GET-Methode:
Die Parameter werden dabei einfach durch ein Fragezeichen an die URL angehängt. Welche Parameter mit der GET-Methode übergeben werden, ist somit für den User sofort ersichtlich.

Beispiel
?search=Katzen&go=Artikel

?
à Beginn Parameterübergabe
Parametername=Parameterwert
&
à Trennung zwischen Parametern

 

POST-Methode:

Im Unterschied zum GET-Request werden bei POST die Parameter nicht an den URL angehängt, sondern im Body des Requests selbst mitgesendet. D.h. die Parameter folgen, nachdem der Header-Bereich mit einer Leerzeile abgetrennt wurde. Die Übergabe von Parametern mittels der POST-Methode ist somit für den User nicht sofort ersichtlich.

Beispiel

Body:

parametername=parameterwert&zweiterparamertname=zweiterparameterwert

1.3               Error-Codes

Nummer

Bezeichnung

1xx

Informationen

2xx

Erfolgreiche Operation

3xx

Umleitung

4xx

Client-Fehler

5xx

Server-Fehler

 

 

 

 

 

 

 

 

Berühmte Errors

·         401 – Unauthorized

·         403 – Forbidden

·         404 - Not Found

·         408 - Request Timeout

·         500 - Internal Server ErrorSessions

1.1               Allgemeines zu Sessions

 

Wir benötigen einen Zustand, sobald man mehrere Anfragen tätigt. Bei einem Web Mailer bspw. loggt sich die Nutzerin einmal ein. Klickt sie im weiteren Verlauf auf eine Mail, um sich diese anzusehen, so werden ihre Logindaten natürlich nicht mehr abgefragt. Sie werden aber auch nicht mit dem Formular oder den Links mitgeschickt. D.h. der Server kann erkennen, dass die Anfrage zu der vorherigen gehört, dass beide Anfragen (und weitere folgende) eine gemeinsame Nutzungssitzung, die Session, bilden.
Das Session-Konzept sieht zum einen ein Erkennungsmerkmal vor, anhand dessen der Webserver trotz des statuslosen Protokolls HTTP erkennen kann, dass mehrere aufeinanderfolgende Requests zu einer Session gehören. Zum anderen ist integraler Bestandteil dieses Konzepts, dass eine Session einen Speicherbereich nutzt, auf den alle Anfragen eben dieser Session zugreifen können, von dem aber Anfragen, die zu anderen Sessions gehören, ausgeschlossen sind. Im Beispiel des Web Mailers könnten in der Session also bspw. die Verbindungsdaten dieser Nutzerin zu ihrem Mail-Provider gespeichert werden. Ebenso, welcher Ordner gerade geöffnet ist, bei mehreren Mailkonten auch, welches dieser Konten gerade aktuell verwaltet wird usw.

 

1.2              Sessions in JSP

// setzen einer Session Variable
session.setAttribute("name", lstrName);

// lesen der Session Variablen
String lstrName = (String) session.getAttribute("name");

// löscht die Session (alle Sessionvariablen)
session.invalidate();

 

1.3               Wann wird eine Session beendet?

Sessions haben nur eine beschränkte Lebensdauer. Zum Beispiel kann die Session-Zeit durch einen Timer festgelegt werden. Weiter wird die Session beendet, wenn der Browser geschlossen wird, Cookies oder Cache gelöscht werden, es einen Stromausfall gibt und dadurch der Computer ausgeschalten wird, oder wenn man sich auf einer Website abmeldet auf welcher man sich mittels eines Logins identifiziert hat.

2          JSP

JSP wird für das Produzieren von dynamischen, webbasierten Inhalten genutzt.
Wenn eine JSP zum ersten Mal aufgerufen wird, wird es zu einem Servlet umgewandelt. Die JSP wird zuerst in Java Code übersetzt und dann kompiliert.
JSP wird für die grafische Darstellung der Inhalte benötigt.

 

 

2.1              Syntax

Die JSP-Tags stehen in einem statischen Code Teil wie HTML oder XML.
Sie stehen immer in ‚<‘ und ‚>‘, es wird kein Semikolon am Ende der Zeile benötigt.

2.2              Aufbau

Eine JSP kann grob in die folgenden Elemente aufgeteilt werden:

·         Die Direktiven

·         Die Skriptingelemente

·         Die Aktionen

 

2.2.1               Direktiven

JSP kennt drei verschiedene Direktiven:

  • Die page Direktiven,
  • Die include Direktiven
  • Die taglib Direktiven
  •  

    Die Syntax einer Direktive hat allgemein die folgende Form:

    <%@ Direktive {Attribut="Wert"}* %>

    2.2.1.1                   Die „page“-Direktive

    Die erste Direktive ist die page-Direktive mit welcher man verschiedene Eigenschaften einer JSP-Seite definieren und ändern kann.

    Die Direktive „page“ kennt folgende Attribute:

    Attribut

    Standardwert

    Beschreibung

    language

    java

    Definiert die verwendete Scripting-Sprache. Es gibt Servlet-Container, welche nebst Java auch Java-Script erlauben.

    extends

    Kann verwendet werden für das definieren der Superklasse, welche verwendet werden soll.

    import

    Importiert benötigte Packate und / oder Klassen.

    session

    true

    Wenn dieser Wert auf true gesetzt ist, wird das implizite Objekt session erstellt und die JSP-Seite "nimmt" an einer Session teil.

    buffer

    8kb

    Definiert die verwendete Buffer-Grösse.

    autoFlush

    true

    Definiert, ob der Buffer automatisch gesendet werden soll, wenn der Buffer voll ist. Wenn dieser Wert false gesetzt wird und der Buffer überläuft, wird eine Exception geworfen.

    isThreadSafe

    true

    Indiziert das Thread-Modell, welches für die Ausführung der "JSP-Seite" vom Servlet-Container verwendet wird. Wenn der Wert auf false gesetzt wird, muss der Servlet-Container alle Anfragen seriell abarbeiten.

    info

    Beschreibung der Seite. Kann mit der API-Funktion getServletInfo() ermittelt werden.

    isErrorPage

    false

    Definiert, ob die aktuelle Seite eine Fehlerseite ist.

    errorPage

    Mit errorPage kann eine URL definiert werden, welche im Fehlerfall aufgerufen wird. Die URL muss zur Applikation gehören und wird relativ angegeben.

    contentType

    text/html

    Definiert den MIME-Typ der Seite.

    pageEncoding

    ISO-8859-1

    Definiert den Zeichensatz.

    isElIgnored

    false

    Definiert, ob die Ausdrücke, welche mittels EL definiert sind, ausgewertet werden sollen.

     

    Die meisten verwendeten Attribute sind sicherlich import und session.

     

    Beispiel:

    <%@ page import="java.util.*" session="false" %>

    Wir importieren das Package java.util und setzen das session-Attribut auf false.

     

    2.2.1.2                   Die „include“-Direktive

    Mit dieser Direktive wird es möglich, den kompletten Inhalt anderer Dateien in die aktuelle Seite einzubinden. Nutzen kann man dies z.B. für stets wieder kehrende HTML-Teile wie Footer und Header. Die Einbindung der Datei geschieht, bevor die JSP-Seite in ein Servlet transformiert wird. Die eingebundene Datei Kann selbst wieder JSP-Elemente beinhalten.

    <%@ include file="datei.jsp" %>.

    2.2.1.3                   Die „taglib“-Direktive

    Mit der Direktive taglib können so genannte tag-libraries eingebunden werden. Z. B. wird die JSP Standard Tag Library mit dieser Direktive eingebunden. URI der Taglibrary kann relativ oder absolut angegeben werden.

    <%@ taglib uri="/TagLibURI" prefix="tagPrefix" %>

     

    Beispiel für eine absolute Angebe des URIs:
    <%@ taglib uri=" prefix="c" %>

    Beispiel für eine relative Angabe eines URIs:
    <%@ taglib uri="/WEB-INF/c.tld" prefix="c" %>

     

    2.2.2              Skriptingelemente

    Scripting-Elemente werden verwendet um Objekte zu manipulieren und Berechnungen durchzuführen und sind "normale" Java-Fragmente. Damit eine JSP-Seite übersichtlich und wartbar bleibt, sollte auf Java-Code innerhalb einer JSP-Seite völlig verzichtet werden.


    Zu den Skriptingelementen gehören:

    ·         Deklarationen

    ·         Scriptlets

    ·         Ausdrücke

    ·         Kommentare

    2.2.2.1                   Deklarationen

    JSP erlaubt Variabeln und Funktionen zu deklarieren. Variabeln werden direkt innerhalb der Klasse erstellt und werden somit zu Klassenvariabeln. Das heisst, dass die deklarierten Variabeln nicht exklusive pro Anfrage und Benutzer verwendetet werden sondern einen globalen Gültigkeitsbereich - innerhalb des Servlets - haben. Diese Variabeln werden auch als "page-level" Variabeln bezeichnet. Bei diesen Variabeln muss immer darauf geachtet werden, dass der Zugriff "Thread-Safe" erfolgt, denn mehrere Threads, können gleichzeitig das gleiche Servlet - unsere JSP-Seite - ausführen.

    Eine Deklaration erfolgt zwischen den Begrenzungszeichen <%! und %>.

     

    Beispiel:

    <%!

    java.util.Date date = java.util.Calendar.getInstance().getTime();

    java.util.Date getCurrentDate() {

      return date;

    }

    %>

    2.2.2.2                  Scriptlets

    Scriptlets sind kleine Kodestücke welche zwischen den Begrenzungszeichen <% und %> stehen. Die Kodestücke können z.B. für das Prüfen von Bedingungen und Schleifen verwendete werden.

     

    Beispiel:

    <body>

      <% for( int i = 0; i < 10; i++ ) {%>

        <% if( i == 0 ) {%>

          Hallo<br><br>

        <%}%>

        Das ist eine JSP-Seite. <br>

      <%}%>

    </body>

     

    2.2.2.3                   Ausdrücke / Expressions

    Ausdrücke sind Scriptlets sehr ähnlich und sind bestimmt für das Auswerten von regulären Java-Ausdrücken. Der Syntax ist wie folgt: <%= ausdruck %>.

     

    Beispiel:

    <body>

      <% for( int i = 0; i < 10; i++ ) {%>

        Zeile <%= i+1%><br>

      <%}%>

    </body>

     

    2.2.2.4                  Kommentare

    In den JSP-Seiten können beliebig mit Kommentar versehen werden. Diese Kommentare werden im Gegensatz zu HTML-Kommentare nicht in die zu generierende Seite übernommen.

     

    Beispiel:

    <%-- Dies ist ein JSP-Kommentar --%>

     

    2.2.3               Action-Elemente

    Die folgenden Aktionen sind verfügbar:

     

    2.2.3.1                   jsp:include

    Die angegebene JSP wird vom Java-Servlet aufgerufen, dabei werden der Request und der Response übergeben. Ist die angegebene JSP abgearbeitet, kommt die Steuerung zur gegenwärtigen JSP zurück. Diese JSP-Aktion bewirkt, dass der eingebettete JSP-Code von allen einbettenden JSPs gemeinsam genutzt und nicht kopiert wird.

     

    Beispiel:

    <jsp:include page="mycommon.jsp">

      <jsp:param name="extraparam" value="myvalue"/>

    </jsp:include>

    2.2.3.2                   jsp:param

    Definiert einen Parameter, der zu den Request-Parametern hinzugefügt wird. Diese Aktion kann innerhalb eines jsp:include- oder jsp:forward-Blocks verwendet werden. Falls der Parameter schon im Request vorhanden war, wird der Parameter überschrieben, also der Wert aus dem „Query String“ mit dem definierten value-Attribut ersetzt.

     

    Beispiel:

    <jsp:params>

      <jsp:param name="enableDebug" value="true"/>

    </jsp:params>

     

    2.2.3.3                   jsp:forward

    der Request und der Response werden an eine andere JSP oder ein Servlet übergeben. Die Steuerung kommt nicht zur gegenwärtigen JSP zurück.

     

    Beispiel:

    <jsp:forward page="subpage.jsp">

      <jsp:param name="forwardedFrom" value="this.jsp"/>

    </jsp:forward>

     

    2.2.3.4                   jsp:plugin

    Diese Aktion generiert je nach verwendetem Browser ein Tag zum Einbinden eines Java-Applets. Dies wird benötigt, da in den älteren Versionen der Browser von Netscape (Navigator) und Microsoft (Internet Explorer) verschiedene Tags zum Einbinden eines Applets verwendet werden.

     

    Beispiel:

    <jsp:plugin type="applet" height="100%" width="100%"

             archive="myjarfile.jar,myotherjar.jar"

             codebase="/applets"

             code="com.example.foo.MyApplet.class">

    </jsp:plugin>

     

    2.2.3.5                   jsp:fallback

    Definiert den Inhalt, der angezeigt wird, falls der Browser keine Applets unterstützt.

     

    Beispiel:

    <jsp:fallback>

        Your browser does not support applets.

    </jsp:fallback>

     

    2.2.3.6                   jsp:setProperty

    Diese Aktion setzt ein Property in der definierten Java-Bean.

     

    Beispiel:

    <jsp:setProperty name="myBean" property="lastChanged" value="<%= new Date()%>" />

     

    2.2.3.7                   jsp:getProperty

    Diese Aktion holt sich ein Property von der definierten Java-Bean.

     

    Beispiel:

    <jsp:getProperty name="myBean" property="lastChanged" />

     

    2.2.3.8                   jsp:useBean

    Diese Aktion erstellt oder verwendet eine Java-Bean wieder. Ist eine Bean vom definierten Typ nicht vorhanden, wird sie also initial neu erstellt. Das optionale Attribut scope gibt an, wie lange die Bean zur Verfügung steht, d. h. in welchem Gültigkeitsbereich die Bean hinterlegt wird. Folgende Werte können definiert werden:

     

    request

    Attribute sind nur solange verfügbar, wie der Request existiert.

    page

    Attribute sind nur für die gegenwärtige JSP verfügbar. (Standard)

    session

    Attribute sind nur solange verfügbar, wie die Benutzer-Session existiert.

    application

    Attribute sind immer verfügbar.

     

    „Verfügbar“ heißt hier, wie lange bzw. von wo der Entwickler auf die Bean zugreifen kann. Ist die Bean beispielsweise im Request-Scope, so kann der Entwickler mit dieser Bean sowohl innerhalb der aktuellen JSP als auch in nachgelagerten (inkludierten) arbeiten. „Page-Scope“ beschränkt den möglichen Zugriff auf die aktuelle JSP-Seite. „Session“ beschreibt alle Requests einer Benutzersitzung zu dieser Web-Anwendung. „Application“ sind alle Requests aller Benutzer der gleichen Web-Anwendung dieses Web-Servers.

     

    Beispiel:

    <jsp:useBean id="myBean" class="com.example.foo.MyBean" scope="request">

    </jsp:useBean>

     

    2.3              Beispiel

    <%-- use the 'taglib' directive to make the JSTL 1.0 core tags available; use the uri

    " for JSTL 1.1 --%>

    <%@ taglib uri=" prefix="c" %>

     

    <%-- use the 'jsp:useBean' standard action to create the Date object;  the object is set

    as an attribute in page scope

    --%>

    <jsp:useBean id="date" class="java.util.Date" />

     

    <html>

    <head><title>First JSP</title></head>

    <body>

    <h2>Here is today's date</h2>

     

    <c:out value="${date}" />

     

    </body>

    </html>

     

    3          Servlets

    3.1               Syntax

    package web;

    import javax.servlet.RequestDispatcher;

    import javax.servlet.ServletException;

    import javax.servlet.http.HttpServlet;

    import javax.servlet.http.HttpServletRequest;

    import javax.servlet.http.HttpServletResponse;

    import java.io.IOException;

     

    public class Logout extends HttpServlet {

        public void doGet(HttpServletRequest request, HttpServletResponse response)

                throws IOException, ServletException {

            …       

          RequestDispatcher view = request.getRequestDispatcher("index.jsp");

                 view.forward(request, response);

        }

    }

    1. Imports
    2. ServletKlasse die von HttpServlet erbt
    3. Void Methoden doGet/doPost/service mit Parameter und Exceptions
      1. HttpServletRequest, HttpServletResponse
      2. IOException, ServletException
    4. Parameter zum Request-Objekt hinzufügen und an JSP-File weiterleiten

    Oder

    1. Direkt mit Response Objekt antworten

     

    3.2              Aufbau

    Das Servlet übernimmt die Steuerung bei einer Webanfrage. Es nimmt die Anfrage entgegen, ruft die entsprechende Klasse mit der Geschäftslogik auf und leitet dann das Ergebnis dieser weiter.

    Ein Servlet ist mit Java aufgebaut. Man kann HTML-Code ausgeben, es ist aber schöner, die Ausgabe über JSP-Seiten zu steuern.

    3 wichtige Zeitpunkte

    init() : Die init()-Methode wird vom Container aufgerufen, nachdem die Servlet-Instanz erzeugt wurde, aber bevor das Servlet auf Anfragen vom Client eingehen kann. Man kann das Servlet initialisieren bevor darauf zugegriffen wird.

    service() : Wenn die erste Anfrage von einem Client hereinkommt legt der Container einen neuen Thread an und veranlasst, dass die service()-Methode aufgerufen wird. Diese Methode sieht sich die Anfrage des Clients an und ermittelt ob es die GET oder POST Methode ist. Entsprechend ruft es doPost() oder doGet() auf.

    doPost/doGet() : Werden je nach HTTP-Methode aufgerufen. Diese Methode ist die, die für alles verantwortlich ist, was die Anwendung machen soll.

     

    3.3               Beispiel

    package web;

     

    //Projektbezogene Imports

    import javax.servlet.*;

    import java.io.IOException;

     

    public class MDetail extends HttpServlet {

     

        public void doGet(HttpServletRequest request, HttpServletResponse response)

                throws IOException, ServletException {

     

            int id = Integer.parseInt(request.getParameter("id"));

            Medium m = CrudMedium.retrieveById(id);

            Ausleihe a = CrudAusleihe.retrieveByMedium(m);

     


            if (a == null) {

                request.setAttribute("ausgeliehen", false);

            } else {

                request.setAttribute("ausgeliehen", true);

            }

            request.setAttribute("medium", m);

     


            RequestDispatcher view =

                    request.getRequestDispatcher("mdetail.jsp");

            view.forward(request, response);

        }

    }

     

    3.4              Konfiguration von web.xml

    <?xml version="1.0" encoding="UTF-8" ?>

    <web-app xmlns=" xmlns:xsi=" xsi:schemaLocation=" version="2.5">

          <servlet>

                <servlet-name>Login</servlet-name>

                <servlet-class>web.Login</servlet-class>

          </servlet>

          <servlet-mapping>

                <servlet-name>Login</servlet-name>

                <url-pattern>/login.do</url-pattern>

          </servlet-mapping>

    </web app>

     

    <url-pattern>/login.do</url-pattern>

    Login.do ist die Url, die der Client zum Servlet sieht, er weiss nicht, in welcher Beziehung dieser Name zu tatsächlichen Verzeichnissen und Dateinamen auf dem Server steht.

    <servlet-name>Login</servlet-name>

    Login ist der interne Name, muss weder der öffentlichen URL, noch dem tatsächlichen Datei- und Pfadnamen der Servlet Klasse entsprechen.

    <servlet-class>web.Login</servlet-class>

    Die Servlet-Klasse hat einen vollständig qualifizierten Namen, der sowohl den Klassennamen als auch den des Packages enthält.

     

    4          Beans

    Beans sind wiederverwendbare Softwarekomponenten, welche dazu dienen, Daten während einer Session im Hintergrund zu speichern und zu bearbeiten. Grundsätzlich werden Beans zur Datenverwaltung benötigt welche auch Verbindungen mit einer Datenbank beinhalten. Dabei wird hauptsächlich mit den Befehlen getVariable bzw. setVariable verwendet. Die Beans können jedoch auch in einer Datenbank abgespeichert werden. Beans werden auch als Container zur Datenübertragung verwendet

    Eigenschaften

    ·         Kompakt, leicht zu erstellen und zu benutzen

    ·         Total portabel

    ·         Robuster, verteilter Rechenmechanismus

    ·         Unterstützung für flexible Entwicklungszeit

    ·         Öffentlicher Standardkonstruktor (Default constructor)

    ·         Serialisierbarkeit (Serializable)

    ·         Öffentliche Zugriffsmethoden (Public Getters/Setters)

    Regeln

    ·         Klassenname: beliebig

    ·         Superklasse: beliebig

    ·         Konstruktor: Mindestens einer ohne Argumente oder eine strukturierte Grundform.

    ·         Packaging: JAR-Datei-Manifesteintrag enthält Java-Bean: True

    ·         Eigenschaften: Alle Eigenschaften müssen durch getEigenschaft und setEigenschaft lesbar bzw. setzbar sein.

    Instanziierung

    Eine Bean besitzt immer einen Konstruktor ohne Argumente (Standardkonstruktor). Dies ermöglicht eine standardisierte Instanziierung, beispielsweise einer Schaltfläche:

    JButton button = (JButton) Class.forName("javax.swing.JButton").newInstance();

    Eine Alternative dieser Instanziierung funktioniert wie folgt:

    JButton button = new JButton();

    4.1              Aufbau

    Der Name Get oder Set Methode muss folgendermassen gestaltet sein:

    Get:

    public Rückgabetyp getAttributname()

    Set:

    public void setAttributname(ParametertypParametername)

    Beispiel:

    Attribut: String foo

    public String getFoo()

    public void setFoo(String foo)

    Wichtig: Der Attributname muss gross geschrieben werden.

    4.2              Beispiel

    4.2.1               In JSP

    <jsp:useBean

    id="beanInstanceName"        // Name der Bean

    scope="page|request|session|application" // Lebensdauer

    {class="package.class"                   // Klasse (inkl. Paketpfad)

    type="package.class"               // Typ des Objektes z.B. List

    class="package.class" type="package.class"  // Klasse und Typ können kombiniert werden

    }

    >

     

    <!-- Other Elements -->

     

    </jsp:useBean> 

    4.2.2              Als Klasse

    package ch.zkb.test.beans;

    public class Person {

                private String vorname;

                private String nachname;

                private int alter;

          public String getVorname() {

                return vorname;

          }

          public void setVorname(String vorname) {

                this.vorname = vorname;

          }

          public String getNachname() {

                return nachname;

          }

          public void setNachname(String nachname) {

                this.nachname = nachname;

          }

          public int getAlter() {

                return alter;

          }

          public void setAlter(int alter) {

                this.alter = alter;

          }

    }

    5          JDBC

    5.1              Allgemeines

    JDBC ist eine Datenbankschnittstelle der Java-Plattform, die eine einheitliche Schnittstelle zu Datenbanken verschiedener Hersteller bietet und speziell auf relationale Datenbanken ausgerichtet ist.

     

    JDBC ist in seiner Funktion als universelle Datenbankschnittstelle vergleichbar mit z.B. ODBC unter Windows.

     

    Zu den Aufgaben von JDBC gehört es, Datenbankverbindungen aufzubauen und zu verwalten, SQL-Anfragen an die Datenbank weiterzuleiten, die Ergebnisse in eine für Java nutzbare Form umzuwandeln und dem Programm zur Verfügung zu stellen.

    5.2              Anwendung

    //1. Treiber laden

          Class.forName("Driver");

     

          //2. Verbindung zur Datenbank herstellen

          Connection conn = DriverManager.getConnection("db", "user", "pw");

     

          //3. Statement erstellen

          Statement statement = conn.createStatement();

     

          //4. Statement ausführen, Ergebnis in ResultSet speichern -->

          ResultSet rset = statement.executeQuery("Statement");

     

          //5. ResultSet auslesen -->

          while(rset.next()){ /* irgendetwas machen */ }

     

          //6. Alles wieder schliessen -->

          rset.close(); statement.close(); conn.close();

     

    5.3              Hilfreiche Websiten

    Tutorial von Sun:

    JDBC Treiber


     

    6          Aufgabe BMI

     

    package pkg1;

     

    import java.io.IOException;

    import javax.servlet.*;

    import javax.servlet.http.*;

     

    public class TestServlet extends HttpServlet {

           private static final long serialVersionUID = 1L;

          

           int zaehler = 1;

          

        public TestServlet() {

            super();

        }

     

           protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

                

                 // Deklarationen

                 String groesse = "";

                 String gewicht = "";

                 String alter = "";

                 String antwort = "";

                 String zuhoch = "";

                 String zutief = "";

                 String io = "";

                 double bmi;

                 double dblgroesse = 0;

                 double dblgewicht = 0;

                 double dblalter = 0;

                

    //           Initialisierungen

                 groesse = request.getParameter("groesse");

                 gewicht = request.getParameter("gewicht");

                 alter = request.getParameter("alter");

                 zuhoch="Das ist zu hoch!";

                 zutief="Das ist zu tief!";

                 io="Das ist in Ordnung";

                

    //           Werte in Doubles umwandeln

                 if (groesse != ""){

                        dblgroesse =  Double.parseDouble(groesse);

                 }

                 if (gewicht != ""){

                        dblgewicht =  Double.parseDouble(gewicht);

                 }

                 if (alter != ""){

                        dblalter = Double.parseDouble(alter);

                 }

                

    //           Wenn in cm angegeben in m umwandeln

                 if(dblgroesse >100){

                        dblgroesse = dblgroesse/100;

                 }

                

    //           BMI berechnen

                 bmi=dblgewicht/(dblgroesse*dblgroesse);

                 bmi= Math.round(bmi*100)/100.0;

                

    //           Abfragen ob man je nach Alter den richtigen BMI hat

                 if (dblalter < 19){

                        antwort="Sie sind nicht alt genug um diesen Rechner zu nutzen!!!";

                 }

                 else if (dblalter < 25){

                        if(bmi < 19){antwort=zutief;}

                        if(bmi > 24){antwort=zuhoch;}

                        else{antwort=io;}

                 }

                 else if (dblalter < 35){

                        if(bmi < 20){antwort=zutief;}

                        if(bmi > 25){antwort=zuhoch;}

                        else{antwort=io;}

                 }

                 else if (dblalter < 45){

                        if(bmi < 21){antwort=zutief;}

                        if(bmi > 26){antwort=zuhoch;}

                        else{antwort=io;}

                 }

                 else if (dblalter < 55){

                        if(bmi < 22){antwort=zutief;}

                        if(bmi > 27){antwort=zuhoch;}

                        else{antwort=io;}

                 }

                 else if (dblalter < 65){

                        if(bmi < 23){antwort=zutief;}

                        if(bmi > 28){antwort=zuhoch;}

                        else{antwort=io;}

                 }

                 else {

                        if(bmi < 24){antwort=zutief;}

                        if(bmi > 29){antwort=zuhoch;}

                        else{antwort=io;}

                 }

                

    //           Ausgaben

                 if (dblalter > 18){

                        response.getOutputStream().println("Ihr BMI ist: " + bmi +"<br>");

                 }

                 response.getOutputStream().println(antwort);

                

     

           }

     

           protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

                

           }

     

    }


     

    7          Aufgabe Session

    7.1               Wichtige Codestellen zum Session-Handling:

    Neue Session im Servlet erstellen:

    HttpSession session = request.getSession(true);

    Session-Attribut setzen:

    session.setAttribute("eingeloggt", eingeloggt);

    Im JSP prüfeon ob User eigelogt ist:

    <%if(session.getAttribute("eingeloggt")=="ja"){%>

    Logout:

    HttpSession session = request.getSession(false);

    session.invalidate();

    response.sendRedirect(" );


    | | | | |
    Tausche dein Hausarbeiten

    G 2 - Cached Page: Thursday 28th of March 2024 10:47:02 AM